@jscad/cli 2.2.26 → 3.0.0-alpha.0

package/src/generateOutputData.js

@@ -1,59 +1,59 @@
-const fs = require('fs')
-const { isAbsolute, resolve } = require('path')
+import fs from 'fs'
+import path from 'path'
+import { createRequire } from 'module'
 
-const { deserializers, solidsAsBlob } = require('@jscad/io')
+import { deserialize, getMimeType, serialize } from '@jscad/io'
+import { convertToBlob } from '@jscad/io-utils'
 
-const { rebuildGeometryCli } = require('@jscad/core').evaluation
-const { registerAllExtensions } = require('@jscad/core').io
+import { evaluation, io } from '@jscad/core'
+
+const { rebuildGeometryCli } = evaluation
+const { registerAllExtensions } = io
 
 /**
- * generate output data from source
+ * Create a promise to convert the given source in inputFormat to the desired outputFormat.
+ * The given CLI params are passed into deserializer, main, and serializer.
  * @param {String} source the original source
- * @param {Object} params hash of parameters to pass to main function
- * @param {String} options
- * @return a Promise with the output data
+ * @param {Object} cliParams - parameters as provided on the command line
+ * @param {Object} options - options for conversion; inputFormat and outputFormat are required
+ * @return {Promise} promise function which can convert the given source
  */
-const generateOutputData = (source, params, options) => {
+export const generateOutputData = (source, cliParams, options) => {
   const defaults = {
     outputFile: undefined,
     outputFormat: 'stl',
     inputFile: '',
     version: '',
-    addMetaData: true
+    addMetaData: true,
+    generateParts: false
   }
   options = Object.assign({}, defaults, options)
-  const { outputFormat, inputFile, inputFormat } = options
 
-  options.filename = inputFile // for deserializers
+  const { inputFile, inputFormat, outputFormat, generateParts } = options
+
+  const inputMimeType = getMimeType(inputFormat)
+  const outputMimeType = getMimeType(outputFormat)
 
-  const inputPath = isAbsolute(inputFile) ? inputFile : resolve(process.cwd(), inputFile)
+  const inputPath = path.isAbsolute(inputFile) ? inputFile : path.resolve(process.cwd(), inputFile)
 
   // setup support for require-ing files with .jscad, .stl etc extensions
+  // HACK create the require function if necessary
+  const require = createRequire(import.meta.url)
   registerAllExtensions(fs, require)
 
   return new Promise((resolve, reject) => {
-    let deserializer = deserializers[inputFormat]
-    if (!deserializer) {
-      if (inputFormat === 'jscad' || inputFormat === 'js') {
-        deserializer = (options, source) => source
-      } else {
-        reject(new Error(`unsuported input format ${inputFormat}`))
-      }
-    }
-
     // convert any inputs
     const prevsource = source
-    const deserializerOptions = Object.assign({}, params, options)
-    source = deserializer(deserializerOptions, source)
+    const deserializerOptions = Object.assign({ output: 'script', filename: inputFile }, cliParams)
+    source = deserialize(deserializerOptions, inputMimeType, source)
     const useFakeFs = (source !== prevsource) // conversion, so use a fake file system when rebuilding
 
-    if (outputFormat === 'jscad' || outputFormat === 'js') {
+    if (outputMimeType === 'application/javascript') {
+      // pass back the source
       resolve(source)
     } else {
-      //    } else if ((inputFormat === 'jscad' || inputFormat === 'js') &&
-      //               outputFormat !== 'jscad' && outputFormat !== 'js') {
       try {
-        const solids = rebuildGeometryCli({ mainPath: inputPath, parameterValues: params, useFakeFs, source })
+        const solids = rebuildGeometryCli({ mainPath: inputPath, parameterValues: cliParams, useFakeFs, source })
         resolve(solids)
       } catch (error) {
         reject(error)
@@ -61,9 +61,25 @@ const generateOutputData = (source, params, options) => {
     }
   })
     .then((solids) => {
-      const serializerOptions = Object.assign({ format: outputFormat }, params)
-      return solidsAsBlob(solids, serializerOptions)
+      if (Array.isArray(solids) && generateParts) {
+        return solids.map((s) => convertSolidsToBlob({ mimeType: outputMimeType, cliParams }, [s]))
+      }
+      return convertSolidsToBlob({ mimeType: outputMimeType, cliParams }, solids)
     })
 }
 
-module.exports = generateOutputData
+/*
+ * Convert the given solids to the target mimeType, and return as a blob for writing to file.
+ */
+const convertSolidsToBlob = (options, solids) => {
+  const { mimeType, cliParams } = options
+
+  if (mimeType === 'application/javascript') {
+    // convert the solids (source code) to blob without conversion
+    return convertToBlob({ data: [solids], mimeType })
+  } else {
+    // convert the solids into the mimeType via serializers
+    const serializerOptions = Object.assign({}, cliParams)
+    return convertToBlob(serialize(serializerOptions, mimeType, solids))
+  }
+}

package/src/parseArgs.js

@@ -1,11 +1,15 @@
-const fs = require('fs')
+import fs from 'fs'
+import path from 'path'
 
-const { getDesignEntryPoint } = require('@jscad/core').loading.requireDesignUtilsFs
-const { supportedInputExtensions, supportedOutputExtensions, supportedOutputFormats } = require('@jscad/io/formats')
+import { loading } from '@jscad/core'
 
-const env = require('./env')
+import { supportedInputExtensions, supportedOutputExtensions, supportedOutputFormats } from '@jscad/io'
 
-const parseArgs = (args) => {
+import { env } from './env.js'
+
+const { getDesignEntryPoint } = loading
+
+export const parseArgs = (args) => {
   const inputExtensions = supportedInputExtensions()
   const outputExtensions = supportedOutputExtensions()
   const outputFormats = supportedOutputFormats()
@@ -13,7 +17,8 @@ const parseArgs = (args) => {
   // hint: https://github.com/substack/node-optimist
   //       https://github.com/visionmedia/commander.js
   if (args.length < 1) {
-    console.log('USAGE:\n\njscad [-v] <file> [-of <format>] [-o <output>]')
+    console.log('USAGE:\n\njscad [-v]\n\n')
+    console.log('jscad [-gp] [-z] <file> [-of <format>] [-o <output>]')
     console.log(`\t<file>  :\tinput (Supported types: folder, .${inputExtensions.join(', .')})`)
     console.log(`\t<output>:\toutput (Supported types: folder, .${outputExtensions.join(', .')})`)
     console.log(`\t<format>:\t${outputFormats.join(', ')}`)
@@ -24,6 +29,8 @@ const parseArgs = (args) => {
   let inputFormat
   let outputFile
   let outputFormat
+  let generateParts = false
+  let zip = false
   const params = {} // parameters to feed the script if applicable
   let addMetaData = false // wether to add metadata to outputs or not : ie version info, timestamp etc
   let inputIsDirectory = false // did we pass in a folder or a file ?
@@ -41,6 +48,10 @@ const parseArgs = (args) => {
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '-of') { // -of <format>
       outputFormat = args[++i]
+    } else if (args[i] === '-gp') {
+      generateParts = true
+    } else if (args[i] === '-z') {
+      zip = true
     } else if (args[i].match(/^-o(\S.+)/)) { // -o<output>
       outputFile = args[i]
       outputFile = outputFile.replace(/^-o(\S+)$/, '$1')
@@ -72,10 +83,10 @@ const parseArgs = (args) => {
           console.log('Verify main or index exists')
           process.exit(1)
         }
-        inputFormat = require('path').extname(inputFile).substring(1)
+        inputFormat = path.extname(inputFile).substring(1)
       } else {
         console.log('ERROR: invalid file name or argument <' + args[i] + '>')
-        console.log("Type 'openjscad' for a list of supported types")
+        console.log("Type 'jscad' for a list of supported types")
         process.exit(1)
       }
     }
@@ -86,16 +97,25 @@ const parseArgs = (args) => {
   if (!outputFormat && !outputFile) {
     outputFormat = 'stla'
   }
+  if (!outputFormat && outputFile) {
+    outputFormat = path.extname(outputFile).substring(1)
+    if (outputFormat === 'stl') outputFormat = 'stla'
+  }
+  if (!outputFormats.includes(outputFormat)) {
+    console.log('ERROR: invalid output format <' + outputFormat + '>')
+    console.log("Type 'jscad' for a list of supported types")
+    process.exit(1)
+  }
 
   return {
     inputFile,
     inputFormat,
     outputFile,
     outputFormat,
+    generateParts,
+    zip,
     params,
     addMetaData,
     inputIsDirectory
   }
 }
-
-module.exports = parseArgs

package/src/writeOutput.js

@@ -1,15 +1,11 @@
-const fs = require('fs')
+import fs from 'fs'
 
-const writeOutputDataToFile = (outputFile, outputData) => {
+export const writeOutput = (outputFile, outputData) => {
   fs.writeFile(outputFile, outputData.asBuffer(),
     (err) => {
       if (err) {
         console.log('err', err)
-      } else {
-        // console.log('success')
       }
     }
   )
 }
-
-module.exports = writeOutputDataToFile