@jscad/core 2.4.0 → 2.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/core",
-  "version": "2.4.0",
+  "version": "2.5.3",
   "description": "Core functionality for JSCAD Applications",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
@@ -34,11 +34,10 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@jscad/array-utils": "2.1.0",
-    "@jscad/io": "2.1.0",
-    "@jscad/io-utils": "2.0.9",
-    "@jscad/modeling": "2.6.0",
-    "@jscad/vtree": "2.0.10",
+    "@jscad/array-utils": "2.1.1",
+    "@jscad/io": "2.2.3",
+    "@jscad/io-utils": "2.0.12",
+    "@jscad/modeling": "2.7.1",
     "json5": "2.2.0",
     "strip-bom": "4.0.0"
   },
@@ -53,5 +52,5 @@
     "url": "https://opencollective.com/openjscad",
     "logo": "https://opencollective.com/openjscad/logo.txt"
   },
-  "gitHead": "3d1d02f2863c65fd95406c7098c09297b3be1c10"
+  "gitHead": "95f05c5f11a53bff469a305d69b99f674dc7d6d3"
 }

package/src/code-evaluation/instanciateDesign.js

@@ -1,5 +1,3 @@
-const makeBuildCachedGeometryFromTree = require('@jscad/vtree').buildCachedGeometry
-
 const isGeom2 = require('@jscad/modeling').geometries.geom2.isA
 const isGeom3 = require('@jscad/modeling').geometries.geom3.isA
 const isPath2 = require('@jscad/modeling').geometries.path2.isA
@@ -18,98 +16,17 @@ const isResultGeometry = (results) => {
   return false
 }
 
-const lookupFromCompactBinary = (compactLookup = {}) => {
-  // console.log('lookupFromCompactBinary', compactLookup)
-  // TODO: optimise this !!
-  const lookup = {}
-  Object.keys(compactLookup).forEach((key) => {
-    const object = compactLookup[key]
-    let result
-    if (object[0] === 0) { // Geom2
-      result = require('@jscad/modeling').geometries.geom2.fromCompactBinary(object)
-    }
-    if (object[0] === 1) { // Geom3
-      result = require('@jscad/modeling').geometries.geom3.fromCompactBinary(object)
-    }
-    if (object[0] === 2) { // Path2
-      result = require('@jscad/modeling').geometries.path2.fromCompactBinary(object)
-    }
-    lookup[key] = result
-  })
-  return lookup
-}
-
-const toJSON = (data) => JSON.stringify(data, (key, value) => {
-  if (value instanceof Int8Array ||
-    value instanceof Uint8Array ||
-    value instanceof Uint8ClampedArray ||
-    value instanceof Int16Array ||
-    value instanceof Uint16Array ||
-    value instanceof Int32Array ||
-    value instanceof Uint32Array ||
-    value instanceof Float32Array ||
-    value instanceof Float64Array) {
-    const replacement = {
-      constructor: value.constructor.name,
-      data: Array.apply([], value),
-      flag: 'FLAG_TYPED_ARRAY'
-    }
-    return replacement
-  }
-  return value
-})
-
-const lookupToCompactBinary = (lookup) => {
-  // FIXME: optimise this !!
-  const compactLookup = {}
-  Object.keys(lookup).forEach((key) => {
-    const object = lookup[key]
-    let result = object
-    if (isGeom2(object)) {
-      compactLookup[key] = require('@jscad/modeling').geometries.geom2.toCompactBinary(object)
-    } else if (isGeom3(object)) {
-      compactLookup[key] = require('@jscad/modeling').geometries.geom3.toCompactBinary(object)
-    } else if (isPath2(object)) {
-      compactLookup[key] = require('@jscad/modeling').geometries.path2.toCompactBinary(object)
-    } else {
-      result = toJSON(object)
-      compactLookup[key] = result
-    }
-  })
-  return compactLookup
-}
-
 const instanciateDesign = (rootModule, parameterValues, options) => {
-  const { vtreeMode, serialize } = options
+  const { serialize } = options
   // deal with the actual solids generation
   let solids
   const rawResults = flatten(toArray(rootModule.main(parameterValues)))
 
-  if (vtreeMode) {
-    console.log('input lookup', options.lookup)
-    let lookup = lookupFromCompactBinary(options.lookup)
-    const lookupCounts = options.lookupCounts || {}
-
-    console.log('lookup after', lookup)
-    // const start = new Date()
-    const buildCachedGeometryFromTree = makeBuildCachedGeometryFromTree({ passesBeforeElimination: 5, lookup, lookupCounts })
-    solids = buildCachedGeometryFromTree({}, rawResults)
-    console.log('created lookup', lookup, lookupCounts)
-    // console.log('solids, vtree', solids, 'lookup', lookup)
-    // console.warn(`buildCachedGeometryFromTree`, new Date() - start)//, rawResults, solids)
-    // TODO: return both solids and cache instead of mutating ?
-    lookup = lookupToCompactBinary(lookup)
-    console.log('compact lookup', lookup)
-
-    solids = serialize ? serializeSolids(solids) : solids
-    return { solids, lookup, lookupCounts }
+  if (isResultGeometry(rawResults)) {
+    solids = serialize ? serializeSolids(rawResults) : rawResults
+    return { solids }
   } else {
-    if (isResultGeometry(rawResults)) {
-      solids = serialize ? serializeSolids(rawResults) : rawResults
-      return { solids }
-    } else {
-      throw new Error('bad output from script: expected geom3/geom2/path2 objects')
-    }
+    throw new Error('bad output from script: expected geom3/geom2/path2 objects')
   }
 }
 

package/src/code-evaluation/rebuildGeometry.js

@@ -12,7 +12,6 @@ const applyParameterDefinitions = require('../parameters/applyParameterDefinitio
  * @param {Array} data.filesAndFolders - array of files / directories
  * @param {String} [data.mainPath] - path of the file containing the main function (optional)
  * @param {Boolean} [data.serialize] - true to serialize the solids into JSON
- * @param {Boolean} [data.vtreeMode] - true to use the experimental Vtree caching (optional)
  * @param {Object} [data.lookup] - geometry cache lookup (optional)
  * @param {Object} [data.lookupCounts] - geometry cache lookup counts (optional)
  * @param {Object} [data.parameterValues] - over-rides of parameter values (optional)
@@ -28,15 +27,14 @@ const rebuildSolids = (data, callback) => {
   console.log('rebuildSolids',data)
   const defaults = {
     mainPath: '',
-    vtreeMode: false,
+    apiMainPath: '@jscad/modeling',
     serialize: false,
     lookup: null,
     lookupCounts: null,
     parameterValues: {}
   }
-  let { mainPath, vtreeMode, serialize, lookup, lookupCounts, parameterValues } = Object.assign({}, defaults, data)
+  let { mainPath, apiMainPath, serialize, lookup, lookupCounts, parameterValues } = Object.assign({}, defaults, data)
 
-  const apiMainPath = '@jscad/modeling'// vtreeMode ? '../code-loading/vtreeApi' : '@jscad/modeling'
   const filesAndFolders = data.filesAndFolders
 
   // let start = new Date()
@@ -56,7 +54,6 @@ const rebuildSolids = (data, callback) => {
   parameterValues = Object.assign({}, designData.parameterValues, parameterValues)
   // start = new Date()
   const options = {
-    vtreeMode,
     lookup,
     lookupCounts,
     serialize

package/src/code-evaluation/rebuildGeometryCli.js

@@ -6,9 +6,11 @@ const getAllParameterDefintionsAndValues = require('../parameters/getParameterDe
 const makeWebRequire = require('../code-loading/webRequire')
 
 const rebuildSolids = (data) => {
-  const defaults = { vtreeMode: false, serialize: false }
-  let { mainPath, vtreeMode, parameterValues, useFakeFs } = Object.assign({}, defaults, data)
-  const apiMainPath = vtreeMode ? '../code-loading/vtreeApi' : '@jscad/modeling'
+  const defaults = {
+    apiMainPath: '@jscad/modeling',
+    serialize: false
+  }
+  let { apiMainPath, serialize, mainPath, parameterValues, useFakeFs } = Object.assign({}, defaults, data)
   // we need to update the source for our module
   let requireFn = require
 

package/src/code-loading/normalizeDesignModule.js

@@ -3,17 +3,17 @@
  */
 const normalizeDesignModule = (rootModule) => {
   if (!rootModule) {
-    throw new Error('no root module found')
+    throw new Error('no root module found, please check the project structure')
   }
   if (typeof (rootModule) === 'function') {
-    console.warn('please use named exports for the main() function')
+    console.warn('please refactor the exports, assigning main() as a property, i.e. module.exports = { main }')
     rootModule = { main: rootModule }
   }
   if (!rootModule.main) {
-    throw new Error('no main() function, check the exports')
+    throw new Error('no main() function found, please check the module.exports')
   }
-  if (!(typeof (rootModule.main) === 'function')) {
-    throw new Error('main is not a function, check the exports')
+  if (typeof (rootModule.main) !== 'function') {
+    throw new Error('main is not a function, please check the module.exports')
   }
   return rootModule
 }

package/src/code-loading/transformSources.js

@@ -1,18 +1,10 @@
 const { deserializers } = require('@jscad/io')
 
-const isCommonJsModule = require('./isCommonJsModule')
-const modulifySource = require('./modulifySource')
-
-const passThroughTransform = (options, entry) => entry
-
-/* function to turn old style jscad code with implicit imports
-into code with explicit exports/imports */
-// FIXME wouldn't a javascript error be better then 'hacking' the users code?
+/*
+ * Transform the entry into a ready-to-use module.
+ */
 const modulifyTransform = (options, entry) => {
-  const { apiMainPath } = options
-  const isFileCommonJs = isCommonJsModule(entry.source)
-  const source = !isFileCommonJs ? modulifySource(entry.source, apiMainPath) : entry.source
-  return Object.assign({}, entry, { source })
+  return Object.assign({}, entry, { source: entry.source })
 }
 
 /*

package/src/code-loading/webRequire.js

@@ -49,7 +49,7 @@ const makeWebRequire = (filesAndFolders, options) => {
     fakeFs: require('./makeFakeFs')(filesAndFolders)
   }
   const { apiMainPath, fakeFs } = Object.assign({}, defaults, options)
-  const apiModule = apiMainPath === '@jscad/modeling' ? require('@jscad/modeling') : require('./vtreeApi')
+  const apiModule = apiMainPath === '@jscad/modeling' ? require('@jscad/modeling') : require(apiMainPath)
 
   // preset core modules
   // FIXME this list of modules should be an option, replacing apiMainPath
@@ -72,6 +72,7 @@ const makeWebRequire = (filesAndFolders, options) => {
   // console.log('*****\n',filesAndFolders,'\n*****')
 
   const extensions = {}
+  const moduleCache = {}
 
   /* Require (obtain) the exports for the given require path, relative to the given current path.
    * The logic is based on the original NODE require() function.
@@ -105,6 +106,7 @@ const makeWebRequire = (filesAndFolders, options) => {
       if (entry.children) return null // directory
 
       if (extensions[baseExt]) {
+        if(moduleCache[requirePath]) return moduleCache[requirePath]
         // evaluate the content
         const matchingModule = {
           exports: {},
@@ -121,7 +123,7 @@ const makeWebRequire = (filesAndFolders, options) => {
           }
         }
         extensions[baseExt](matchingModule, entry.fullPath)
-        return matchingModule.exports
+        return moduleCache[requirePath] = matchingModule.exports
       }
       return null
     }

package/src/code-loading/webRequire.test.js

@@ -13,10 +13,14 @@ test('webRequire: should support require, from a single file', (t) => {
 
   let requireFn = makeWebRequire(singleFileJs, { apiMainPath })
   let designRootModule = requireFn(singleFileJs[0].fullPath)
+  const designRootModule2 = requireFn(singleFileJs[0].fullPath)
 
   t.true('main' in designRootModule)
   t.true(designRootModule.main instanceof Function)
 
+  t.is(designRootModule, designRootModule2)
+  t.deepEqual(designRootModule, designRootModule2)
+
   // NOTE: 'jscad' must be registered as an extension
   const fakeFs = makeFakeFs(singleFileJscad)
   requireFn = makeWebRequire(singleFileJscad, { apiMainPath })
@@ -32,7 +36,6 @@ test('webRequire: should support require, from a directory with index.js', (t) =
 
   const requireFn = makeWebRequire(directoryWithIndexJs, { apiMainPath })
   const designRootModule = requireFn('/project')
-
   t.true('main' in designRootModule)
   t.true(designRootModule.main instanceof Function)
 })