@jscad/cli 2.2.26 → 3.0.0-alpha.0

package/cli.conversions.test.js

@@ -1,8 +1,10 @@
-const test = require('ava')
+import fs from 'fs'
+import path from 'path'
+import { cwd } from 'process'
 
-const path = require('path')
-const { execSync } = require('child_process')
-const fs = require('fs')
+import test from 'ava'
+
+import { execSync } from 'child_process'
 
 test.afterEach.always((t) => {
   // remove files
@@ -26,7 +28,7 @@ test.afterEach.always((t) => {
 test.beforeEach((t) => {
   const cliName = './cli.js'
   t.context = {
-    cliPath: path.resolve(__dirname, cliName)
+    cliPath: path.resolve(cwd(), cliName)
   }
 })
 
@@ -38,32 +40,30 @@ test.beforeEach((t) => {
 // the script should produce ALL geometry types
 const createJscad = (id) => {
   const jscadScript = `// test script ${id}
-const { flatten } = require('@jscad/array-utils')
-const { primitives } = require('@jscad/modeling')
+import { flatten } from '@jscad/array-utils'
+import { arc, ellipse, ellipsoid } from '@jscad/modeling'
 
-const getParameterDefinitions = () => {
+export const getParameterDefinitions = () => {
   return flatten([
     { name: 'segments', caption: 'Segements:', type: 'int', initial: 10, min: 5, max: 20, step: 1 }
   ])
 }
 
-const main = (params) => {
+export const main = (params) => {
   // parameters
   let segments = params.segments || 16
 
   // shapes
-  let apath2 = primitives.arc()
-  let ageom2 = primitives.ellipse()
-  let ageom3 = primitives.ellipsoid()
+  let apath2 = arc()
+  let ageom2 = ellipse()
+  let ageom3 = ellipsoid()
 
   return [apath2, ageom2, ageom3]
 }
-
-module.exports = { main, getParameterDefinitions }
 `
 
-  const fileName = `./test${id}.jscad`
-  const filePath = path.resolve(__dirname, fileName)
+  const fileName = `./base${id}.js`
+  const filePath = path.resolve(cwd(), fileName)
   fs.writeFileSync(filePath, jscadScript)
   return filePath
 }
@@ -78,20 +78,20 @@ test('cli (conversions STL)', (t) => {
   t.context.file1Path = file1Path
 
   const file2Name = `./test${testID}.stl`
-  const file2Path = path.resolve(__dirname, file2Name)
+  const file2Path = path.resolve(cwd(), file2Name)
   t.false(fs.existsSync(file2Path))
 
   t.context.file2Path = file2Path
 
   const cliPath = t.context.cliPath
 
-  let cmd = `node ${cliPath} ${file1Path}`
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file2Path))
 
   // convert from STL to JSCAD script
   const file3Name = `./test${testID}.js`
-  const file3Path = path.resolve(__dirname, file3Name)
+  const file3Path = path.resolve(cwd(), file3Name)
   t.false(fs.existsSync(file3Path))
 
   t.context.file3Path = file3Path
@@ -111,53 +111,20 @@ test('cli (conversions DXF)', (t) => {
   t.context.file1Path = file1Path
 
   const file2Name = `./test${testID}.dxf`
-  const file2Path = path.resolve(__dirname, file2Name)
+  const file2Path = path.resolve(cwd(), file2Name)
   t.false(fs.existsSync(file2Path))
 
   t.context.file2Path = file2Path
 
   const cliPath = t.context.cliPath
 
-  let cmd = `node ${cliPath} ${file1Path} -of dxf`
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file2Path))
 
   // convert from DXF to JS
   const file3Name = `./test${testID}.js`
-  const file3Path = path.resolve(__dirname, file3Name)
-  t.false(fs.existsSync(file3Path))
-
-  t.context.file3Path = file3Path
-
-  cmd = `node ${cliPath} ${file2Path} -of js`
-  execSync(cmd, { stdio: [0, 1, 2] })
-  t.true(fs.existsSync(file3Path))
-})
-
-test('cli (conversions AMF)', (t) => {
-  const testID = 13
-
-  // convert from JSCAD to AMF
-  const file1Path = createJscad(testID)
-  t.true(fs.existsSync(file1Path))
-
-  t.context.file1Path = file1Path
-
-  const file2Name = `./test${testID}.amf`
-  const file2Path = path.resolve(__dirname, file2Name)
-  t.false(fs.existsSync(file2Path))
-
-  t.context.file2Path = file2Path
-
-  const cliPath = t.context.cliPath
-
-  let cmd = `node ${cliPath} ${file1Path} -of amf`
-  execSync(cmd, { stdio: [0, 1, 2] })
-  t.true(fs.existsSync(file2Path))
-
-  // convert from AMF to JS
-  const file3Name = `./test${testID}.js`
-  const file3Path = path.resolve(__dirname, file3Name)
+  const file3Path = path.resolve(cwd(), file3Name)
   t.false(fs.existsSync(file3Path))
 
   t.context.file3Path = file3Path
@@ -177,20 +144,20 @@ test('cli (conversions JSON)', (t) => {
   t.context.file1Path = file1Path
 
   const file2Name = `./test${testID}.json`
-  const file2Path = path.resolve(__dirname, file2Name)
+  const file2Path = path.resolve(cwd(), file2Name)
   t.false(fs.existsSync(file2Path))
 
   t.context.file2Path = file2Path
 
   const cliPath = t.context.cliPath
 
-  let cmd = `node ${cliPath} ${file1Path} -of json`
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file2Path))
 
   // convert from JSON to JS
   const file3Name = `./test${testID}.js`
-  const file3Path = path.resolve(__dirname, file3Name)
+  const file3Path = path.resolve(cwd(), file3Name)
   t.false(fs.existsSync(file3Path))
 
   t.context.file3Path = file3Path
@@ -210,20 +177,20 @@ test('cli (conversions SVG)', (t) => {
   t.context.file1Path = file1Path
 
   const file2Name = `./test${testID}.svg`
-  const file2Path = path.resolve(__dirname, file2Name)
+  const file2Path = path.resolve(cwd(), file2Name)
   t.false(fs.existsSync(file2Path))
 
   t.context.file2Path = file2Path
 
   const cliPath = t.context.cliPath
 
-  let cmd = `node ${cliPath} ${file1Path} -of svg`
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file2Path))
 
   // convert from SVG to JS
   const file3Name = `./test${testID}.js`
-  const file3Path = path.resolve(__dirname, file3Name)
+  const file3Path = path.resolve(cwd(), file3Name)
   t.false(fs.existsSync(file3Path))
 
   t.context.file3Path = file3Path
@@ -243,20 +210,20 @@ test('cli (conversions X3D)', (t) => {
   t.context.file1Path = file1Path
 
   const file2Name = `./test${testID}.x3d`
-  const file2Path = path.resolve(__dirname, file2Name)
+  const file2Path = path.resolve(cwd(), file2Name)
   t.false(fs.existsSync(file2Path))
 
   t.context.file2Path = file2Path
 
   const cliPath = t.context.cliPath
 
-  let cmd = `node ${cliPath} ${file1Path} -of x3d`
+  let cmd = `node ${cliPath} ${file1Path} -o ${file2Path}`
   execSync(cmd, { stdio: [0, 1, 2] })
   t.true(fs.existsSync(file2Path))
 
   // convert from X3D to JS
   const file3Name = `./test${testID}.js`
-  const file3Path = path.resolve(__dirname, file3Name)
+  const file3Path = path.resolve(cwd(), file3Name)
   t.false(fs.existsSync(file3Path))
 
   t.context.file3Path = file3Path

package/cli.js

@@ -21,19 +21,21 @@
 //   jscad test.jscad -of stl
 //   jscad name_plate.jscad --name "Just Me" --title "CEO" -o amf test.amf
 //
-const fs = require('fs')
+import fs from 'fs'
+import JSZip from 'jszip'
 
-const { formats } = require('@jscad/io/formats')
+import { supportedFormats } from '@jscad/io'
 
-const version = require('./package.json').version
-const generateOutputData = require('./src/generateOutputData')
-const determineOutputNameAndFormat = require('./src/determineOutputNameAndFormat')
-const writeOutput = require('./src/writeOutput')
-const parseArgs = require('./src/parseArgs')
+import { generateOutputData } from './src/generateOutputData.js'
+import { determineOutputNameAndFormat } from './src/determineOutputNameAndFormat.js'
+import { writeOutput } from './src/writeOutput.js'
+import { parseArgs } from './src/parseArgs.js'
+
+const version = '[VI]{version}[/VI]' // version is injected by rollup
 
 // handle arguments (inputs, outputs, etc)
 const args = process.argv.splice(2)
-let { inputFile, inputFormat, outputFile, outputFormat, params, addMetaData, inputIsDirectory } = parseArgs(args)
+let { inputFile, inputFormat, outputFile, outputFormat, generateParts, zip, params, addMetaData, inputIsDirectory } = parseArgs(args)
 
 // outputs
 const output = determineOutputNameAndFormat(outputFormat, outputFile, inputFile)
@@ -48,18 +50,68 @@ const clicolors = {
   black: '\u{1b}[0m'
 }
 
-console.log(`${clicolors.blue}JSCAD: generating output ${clicolors.red}
- from: ${clicolors.green} ${inputFile} ${clicolors.red}
- to: ${clicolors.green} ${outputFile} ${clicolors.yellow}(${formats[outputFormat].description}) ${clicolors.black}
-`)
+const logFileOutput = (outputFile) => {
+  console.log(`${clicolors.blue}JSCAD: generating output ${clicolors.red}
+    from: ${clicolors.green} ${inputFile} ${clicolors.red}
+    to: ${clicolors.green} ${outputFile} ${clicolors.yellow}(${supportedFormats[outputFormat].description}) ${clicolors.black}
+  `)
+}
 
 // read input data
-const src = fs.readFileSync(inputFile, inputFile.match(/\.stl$/i) ? 'binary' : 'UTF8')
+let encoding = 'UTF8'
+if (inputFile.match(/\.stl$/i)) encoding = 'binary'
+if (inputFile.match(/\.3mf$/i)) encoding = null // force raw buffer
+
+const src = fs.readFileSync(inputFile, encoding)
 
 // -- convert from JSCAD script into the desired output format
 // -- and write it to disk
-generateOutputData(src, params, { outputFile, outputFormat, inputFile, inputFormat, version, addMetaData, inputIsDirectory })
-  .then((outputData) => writeOutput(outputFile, outputData))
+generateOutputData(src, params, { outputFile, outputFormat, inputFile, inputFormat, generateParts, version, addMetaData, inputIsDirectory })
+  .then((outputData) => {
+    if (outputData instanceof Array) {
+      if (zip) {
+        const zip = new JSZip()
+        for (let i = 0; i < outputData.length; i++) {
+          const filename = outputFile.replace(/\.(\w+)$/, `-part-${i + 1}-of-${outputData.length}.$1`)
+          zip.file(filename, outputData[i].asBuffer())
+        }
+        zip.generateAsync({ type: 'nodebuffer' }).then((content) => {
+          const zipFilename = outputFile.replace(/\.(\w+)$/, '.zip')
+          fs.writeFile(zipFilename, content, (err) => {
+            if (err) {
+              console.error(err)
+            } else {
+              logFileOutput(zipFilename)
+            }
+          })
+        })
+      } else {
+        for (let i = 0; i < outputData.length; i++) {
+          const filename = outputFile.replace(/\.(\w+)$/, `-part-${i + 1}-of-${outputData.length}.$1`)
+          logFileOutput(filename)
+          writeOutput(filename, outputData[i])
+        }
+      }
+    } else {
+      if (zip) {
+        const zip = new JSZip()
+        zip.file(outputFile, outputData.asBuffer())
+        zip.generateAsync({ type: 'nodebuffer' }).then((content) => {
+          const zipFilename = outputFile.replace(/\.(\w+)$/, '.zip')
+          fs.writeFile(zipFilename, content, (err) => {
+            if (err) {
+              console.error(err)
+            } else {
+              logFileOutput(zipFilename)
+            }
+          })
+        })
+      } else {
+        logFileOutput(outputFile)
+        writeOutput(outputFile, outputData)
+      }
+    }
+  })
   .catch((error) => {
     console.error(error)
     process.exit(1)

package/cli.parameters.test.js

@@ -1,8 +1,15 @@
-const test = require('ava')
+import fs from 'fs'
+import { dirname, resolve } from 'path'
+import { execSync } from 'child_process'
+import { cwd } from 'process'
+import { fileURLToPath } from 'url'
 
-const path = require('path')
-const { execSync } = require('child_process')
-const fs = require('fs')
+import JSZip from 'jszip'
+
+import test from 'ava'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
 
 test.afterEach.always((t) => {
   // remove files
@@ -13,6 +20,12 @@ test.afterEach.always((t) => {
   try {
     if (t.context.outputPath) fs.unlinkSync(t.context.outputPath)
   } catch (err) {}
+  try {
+    if (t.context.outputPath2) fs.unlinkSync(t.context.outputPath2)
+  } catch (err) {}
+  try {
+    if (t.context.outputPath3) fs.unlinkSync(t.context.outputPath3)
+  } catch (err) {}
 
   try {
     if (t.context.folderPath) fs.rmdirSync(t.context.folderPath, { recursive: false })
@@ -22,7 +35,7 @@ test.afterEach.always((t) => {
 test.beforeEach((t) => {
   const cliName = './cli.js'
   t.context = {
-    cliPath: path.resolve(__dirname, cliName)
+    cliPath: resolve(cwd(), cliName)
   }
 })
 
@@ -32,33 +45,31 @@ test.beforeEach((t) => {
 
 // create a simple JSCAD script for input
 // the script should produce ALL geometry types
-const createJscad = (id) => {
+const createJscad = (id, multipart = false) => {
   const jscadScript = `// test script ${id}
-const { primitives } = require('@jscad/modeling')
+import { arc, ellipse, ellipsoid } from '@jscad/modeling'
 
-const getParameterDefinitions = () => {
+export const getParameterDefinitions = () => {
   return [
-    { name: 'segments', caption: 'Segements:', type: 'int', initial: 10, min: 5, max: 20, step: 1 }
+    { name: 'segments', caption: 'Segments:', type: 'int', initial: 10, min: 5, max: 20, step: 1 }
   ]
 }
 
-const main = (params) => {
+export const main = (params) => {
   // parameters
   let segments = params.segments || 16
 
   // shapes
-  let apath2 = primitives.arc()
-  let ageom2 = primitives.ellipse()
-  let ageom3 = primitives.ellipsoid()
+  let apath2 = arc()
+  let ageom2 = ellipse()
+  let ageom3 = ellipsoid()
 
-  return [apath2, ageom2, ageom3]
+  ${multipart ? 'return [ageom3, ageom3, ageom3]' : 'return [apath2, ageom2, ageom3]'}
 }
-
-module.exports = { main, getParameterDefinitions }
 `
 
-  const fileName = `./test${id}.jscad`
-  const filePath = path.resolve(__dirname, fileName)
+  const fileName = `./test${id}.js`
+  const filePath = resolve(cwd(), fileName)
   fs.writeFileSync(filePath, jscadScript)
   return filePath
 }
@@ -72,7 +83,7 @@ test('cli (single input file)', (t) => {
   t.context.inputPath = inputPath
 
   const outputName = `./test${testID}.stl`
-  const outputPath = path.resolve(__dirname, outputName)
+  const outputPath = resolve(cwd(), outputName)
   t.false(fs.existsSync(outputPath))
 
   t.context.outputPath = outputPath
@@ -93,7 +104,7 @@ test('cli (single input file, output format)', (t) => {
   t.context.inputPath = inputPath
 
   const outputName = `./test${testID}.dxf`
-  const outputPath = path.resolve(__dirname, outputName)
+  const outputPath = resolve(cwd(), outputName)
   t.false(fs.existsSync(outputPath))
 
   t.context.outputPath = outputPath
@@ -113,8 +124,8 @@ test('cli (single input file, output filename)', (t) => {
 
   t.context.inputPath = inputPath
 
-  const outputName = `./test${testID}.amf`
-  const outputPath = path.resolve(__dirname, outputName)
+  const outputName = `./test${testID}.obj`
+  const outputPath = resolve(cwd(), outputName)
   t.false(fs.existsSync(outputPath))
 
   t.context.outputPath = outputPath
@@ -134,7 +145,7 @@ test('cli (folder, output format)', (t) => {
 
   t.context.inputPath = inputPath
 
-  const folderPath = path.resolve(__dirname, './test-folder')
+  const folderPath = resolve(cwd(), './test-folder')
   t.false(fs.existsSync(folderPath))
 
   fs.mkdirSync(folderPath)
@@ -142,14 +153,14 @@ test('cli (folder, output format)', (t) => {
 
   t.context.folderPath = folderPath
 
-  const mainPath = path.resolve(__dirname, './test-folder/main.js')
+  const mainPath = resolve(cwd(), './test-folder/main.js')
   fs.renameSync(inputPath, mainPath)
   t.true(fs.existsSync(mainPath))
 
   t.context.inputPath = mainPath
 
   const outputName = './test-folder/main.dxf'
-  const outputPath = path.resolve(__dirname, outputName)
+  const outputPath = resolve(cwd(), outputName)
   t.false(fs.existsSync(outputPath))
 
   t.context.outputPath = outputPath
@@ -170,7 +181,7 @@ test('cli (single input file, parameters)', (t) => {
   t.context.inputPath = inputPath
 
   const outputName = `./test${testID}.stl`
-  const outputPath = path.resolve(__dirname, outputName)
+  const outputPath = resolve(cwd(), outputName)
   t.false(fs.existsSync(outputPath))
 
   t.context.outputPath = outputPath
@@ -182,7 +193,7 @@ test('cli (single input file, parameters)', (t) => {
   t.true(fs.existsSync(outputPath))
 })
 
-test('cli (no parameters)', (t) => {
+test('cli (no parameters, out help)', (t) => {
   const cliPath = t.context.cliPath
 
   const cmd = `node ${cliPath}`
@@ -207,3 +218,88 @@ test('cli (single input file, invalid jscad)', (t) => {
     execSync(cmd, { stdio: [0, 1, 2] })
   })
 })
+
+test('cli (single input file, multiple output files)', (t) => {
+  const testID = 7
+
+  const inputPath = createJscad(testID, true)
+  t.true(fs.existsSync(inputPath))
+
+  t.context.inputPath = inputPath
+
+  const outputName = (partNum) => `./test${testID}-part-${partNum}-of-3.stl`
+  const outputPath1 = resolve(__dirname, outputName(1))
+  const outputPath2 = resolve(__dirname, outputName(2))
+  const outputPath3 = resolve(__dirname, outputName(3))
+  t.false(fs.existsSync(outputPath1))
+  t.false(fs.existsSync(outputPath2))
+  t.false(fs.existsSync(outputPath3))
+
+  t.context.outputPath = outputPath1
+  t.context.outputPath2 = outputPath2
+  t.context.outputPath3 = outputPath3
+
+  const cliPath = t.context.cliPath
+
+  const cmd = `node ${cliPath} ${inputPath} -gp`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(outputPath1))
+  t.true(fs.existsSync(outputPath2))
+  t.true(fs.existsSync(outputPath3))
+})
+
+test('cli (single multipart input file, zipped output file)', async (t) => {
+  const testID = 8
+
+  const inputPath = createJscad(testID, true)
+  t.true(fs.existsSync(inputPath))
+
+  t.context.inputPath = inputPath
+
+  const outputName = `./test${testID}.zip`
+  const outputPath = resolve(__dirname, outputName)
+
+  t.false(fs.existsSync(outputPath))
+
+  t.context.outputPath = outputPath
+
+  const cliPath = t.context.cliPath
+
+  const cmd = `node ${cliPath} ${inputPath} -gp -z`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(outputPath))
+
+  // check contents of zip file
+  const data = await fs.promises.readFile(outputPath)
+  const content = await JSZip.loadAsync(data)
+  t.true(content.files[resolve(__dirname, `./test${testID}-part-1-of-3.stl`)] !== undefined)
+  t.true(content.files[resolve(__dirname, `./test${testID}-part-2-of-3.stl`)] !== undefined)
+  t.true(content.files[resolve(__dirname, `./test${testID}-part-3-of-3.stl`)] !== undefined)
+})
+
+test('cli (single input file, zipped output file)', async (t) => {
+  const testID = 9
+
+  const inputPath = createJscad(testID, true)
+  t.true(fs.existsSync(inputPath))
+
+  t.context.inputPath = inputPath
+
+  const outputName = `./test${testID}.zip`
+  const outputPath = resolve(__dirname, outputName)
+
+  t.false(fs.existsSync(outputPath))
+
+  t.context.outputPath = outputPath
+
+  const cliPath = t.context.cliPath
+
+  const cmd = `node ${cliPath} ${inputPath} -z`
+  execSync(cmd, { stdio: [0, 1, 2] })
+  t.true(fs.existsSync(outputPath))
+
+  // check contents of zip file
+  const data = await fs.promises.readFile(outputPath)
+  const content = await JSZip.loadAsync(data)
+  t.true(content.files[resolve(__dirname, `./test${testID}.stl`)] !== undefined)
+})

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@jscad/cli",
-  "version": "2.2.26",
+  "version": "3.0.0-alpha.0",
   "description": "Command Line Interface (CLI) for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
+  "type": "module",
   "bin": {
     "jscad": "./cli.js"
   },
   "scripts": {
-    "coverage": "nyc --all --reporter=html --reporter=text npm test",
+    "coverage": "c8 --all --reporter=html --reporter=text npm test",
     "test": "ava '*.test.js' --serial --verbose --timeout 2m",
     "postinstall": "node -e \"console.log('\\u001b[35m\\u001b[1mLove JSCAD? You can now donate to our open collective:\\u001b[22m\\u001b[39m\\n > \\u001b[34mhttps://opencollective.com/openjscad/donate\\u001b[0m')\""
   },
@@ -35,19 +36,21 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@jscad/array-utils": "2.1.4",
-    "@jscad/core": "2.6.6",
-    "@jscad/io": "2.4.5",
-    "@jscad/modeling": "2.11.1"
+    "@jscad/array-utils": "3.0.0-alpha.0",
+    "@jscad/core": "3.0.0-alpha.0",
+    "@jscad/io": "3.0.0-alpha.0",
+    "@jscad/io-utils": "3.0.0-alpha.0",
+    "@jscad/modeling": "3.0.0-alpha.0",
+    "jszip": "^3.10.1"
   },
   "devDependencies": {
-    "ava": "3.15.0",
-    "nyc": "15.1.0"
+    "ava": "^4.3.3",
+    "c8": "^8.0.0"
   },
   "collective": {
     "type": "opencollective",
     "url": "https://opencollective.com/openjscad",
     "logo": "https://opencollective.com/openjscad/logo.txt"
   },
-  "gitHead": "4313974b50957018d2edd010e3a251f59bea46a4"
+  "gitHead": "3656d36ed9cd738ab884e86aae5a2ce08d52adf7"
 }

package/src/determineOutputNameAndFormat.js

@@ -1,6 +1,6 @@
-const { supportedOutputExtensions, supportedOutputFormats } = require('@jscad/io/formats')
+import { supportedOutputExtensions, supportedOutputFormats } from '@jscad/io'
 
-const determineOutputNameAndFormat = (outputFormat, outputFile, inputFile) => {
+export const determineOutputNameAndFormat = (outputFormat, outputFile, inputFile) => {
   const extReg = new RegExp(`\\.(${supportedOutputExtensions().join('|')})$`)
   const forReg = new RegExp(`(${supportedOutputFormats().join('|')})`, 'i')
 
@@ -22,5 +22,3 @@ const determineOutputNameAndFormat = (outputFormat, outputFile, inputFile) => {
   }
   return { outputFormat, outputFile }
 }
-
-module.exports = determineOutputNameAndFormat

package/src/env.js

@@ -1,17 +1,14 @@
-const version = require('../package.json').version
+import os from 'os'
 
-const env = () => {
+const version = '[VI]{version}[/VI]' // version is injected by rollup
+
+export const env = () => {
   let env = 'JSCAD ' + version
   if (typeof document !== 'undefined') {
     const w = document.defaultView
     env = env + ' [' + w.navigator.userAgent + ']'
   } else {
-    if (typeof require === 'function') {
-      const os = require('os')
-      env = env + ' [' + os.type() + ':' + os.release() + ',' + os.platform() + ':' + os.arch() + ']'
-    }
+    env = env + ' [' + os.type() + ':' + os.release() + ',' + os.platform() + ':' + os.arch() + ']'
   }
   console.log(env)
 }
-
-module.exports = env