@jscad/core 2.3.4 → 2.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/core",
-  "version": "2.3.4",
+  "version": "2.3.8",
   "description": "Core functionality for JSCAD Applications",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
@@ -35,10 +35,11 @@
   "license": "MIT",
   "dependencies": {
     "@jscad/array-utils": "2.1.0",
-    "@jscad/io": "2.0.5",
-    "@jscad/io-utils": "2.0.4",
-    "@jscad/modeling": "2.4.0",
-    "@jscad/vtree": "2.0.5",
+    "@jscad/io": "2.0.9",
+    "@jscad/io-utils": "2.0.8",
+    "@jscad/modeling": "2.5.3",
+    "@jscad/vtree": "2.0.9",
+    "json5": "2.2.0",
     "strip-bom": "4.0.0"
   },
   "devDependencies": {
@@ -52,5 +53,5 @@
     "url": "https://opencollective.com/openjscad",
     "logo": "https://opencollective.com/openjscad/logo.txt"
   },
-  "gitHead": "ec60e9f144d712750731f19dbad75f8ed913a51e"
+  "gitHead": "0bfbc72afe89ef8dc4f332acf55858831f173d6e"
 }

package/src/code-loading/webRequire.js

@@ -4,6 +4,7 @@ const path = require('path')
 const posix = path.posix ? path.posix : path
 
 const getFileExtensionFromString = require('../utils/getFileExtensionFromString')
+const { combineParameterDefinitions, getParameterDefinitionsFromSource } = require('../parameters/getParameterDefinitionsFromSource')
 
 /* find matching path in inputs
  * @param  {} path
@@ -110,6 +111,11 @@ const makeWebRequire = (filesAndFolders, options) => {
           _compile: (content, fileName) => {
             const moduleMakerFunction = new Function('require', 'module', content)
             moduleMakerFunction(_require.bind(null, entry.fullPath), matchingModule)
+
+            const paramDefFromSource = content.includes('@jscad-params') ? getParameterDefinitionsFromSource(content, fileName) : []
+            const originalFunc = matchingModule.exports.getParameterDefinitions
+            // replace getParameterDefinitions in the module, with version taht adds parsed definitions
+            matchingModule.exports.getParameterDefinitions = () => combineParameterDefinitions(paramDefFromSource, originalFunc ? originalFunc() || [] : [])
             // add to core to resolve later references
             // FIXME coreModules[entry.fullPath] = matchingModule.exports
           }

package/src/parameters/getParameterDefinitionsFromSource.js

@@ -0,0 +1,194 @@
+const JSON5 = require('json5')
+
+/* Count leading spaces in a line.
+This helps provide more descriptive comments after the parameter.
+
+When comment is foundm the number of spaces can be compared with previous parameter definition.
+When comment line is indented more than parameter(incl. parameter name)
+it is considered as description of previous parameter and not a group definition.
+
+*/
+const countSpaces = (l) => {
+  let count = 0
+  for (let i = 0; i < l.length; i++) {
+    if (l[i] === ' ') count++
+    else if (l[i] === '\t') count += 2
+    else break
+  }
+  return count
+}
+
+const getParameterDefinitionsFromSource = (script) => {
+  const lines = []
+  script.split('\n').forEach((l, i) => {
+    const trim = l.trim()
+    if (trim) {
+      lines.push({ code: trim, line: l, lineNum: i + 1, indent: countSpaces(l) })
+    }
+  })
+
+  let i = 0; let lineNum; let code; let prev; let prevIndent
+  while (i < lines.length) {
+    code = lines[i].code
+    i++
+    if (code.length > 12 && code.indexOf('@jscad-params') !== -1) break
+  }
+
+  let groupIndex = 1
+  const defs = []
+
+  while (i < lines.length) {
+    code = lines[i].code
+    lineNum = lines[i].lineNum
+    if (code[0] === '}') break
+
+    const isGroup = code[0] === '/'
+    if (isGroup && prev) {
+      const isHint = prev.type === 'group' || prevIndent + prev.name.length <= lines[i].indent
+      if (isHint) {
+        prev.hint = prev.hint ? prev.hint + '\n' : ''
+        prev.hint += extractTextFromComment(code, lineNum)
+        i++
+        continue
+      }
+    }
+
+    prevIndent = lines[i].indent
+    if (isGroup) {
+      // group
+      const name = '_group_' + (groupIndex++)
+      const def = parseComment(code, lineNum, name)
+      let caption = def.caption
+      if (caption[0] === '>') {
+        caption = caption.substring(1).trim()
+        if (!def.options) def.options = {}
+        def.options.initial = 'closed'
+      }
+
+      defs.push(prev = { name, type: 'group', caption, ...def.options })
+    } else {
+      const idx = code.indexOf('/')
+      if (idx === -1) {
+        // also handle case when closing bracket is in same line as last parameter
+        //   width=11}
+        // it is not an exhaustive check but covers aditional case to simplify it for users
+        const bracketIdx = code.indexOf('}')
+        if (bracketIdx !== -1) code = code.substring(0, bracketIdx)
+
+        const def = parseDef(code, lineNum)
+        def.caption = def.name
+        defs.push(prev = def)
+
+        if (bracketIdx !== -1) break
+      } else {
+        defs.push(prev = parseOne(
+          code.substring(idx).trim(),
+          code.substring(0, idx).trim(),
+          lineNum, lineNum
+        ))
+      }
+    }
+    i++
+  }
+
+  return defs
+}
+
+const parseOne = (comment, code, line1, line2) => {
+  let def = parseDef(code, line2)
+  const { caption, options } = parseComment(comment, line1, def.name)
+  def.caption = caption || def.name
+  if (options) {
+    def = { ...def, ...options }
+    if (def.type === 'checkbox' && 'initial' in def) def.checked = true
+    if (def.type === 'slider') {
+      if (def.min === undefined) {
+        def.min = 0
+      }
+      if (def.max === undefined) {
+        def.max = 100
+      }
+    }
+  }
+
+  return def
+}
+
+const extractTextFromComment = (c, lineNum) => {
+  const prefix = c.substring(0, 2)
+  // after cutting-out the comment marker, there could be more spaces to trim
+  if (prefix === '//') c = c.substring(2).trim()
+  if (prefix === '/*') {
+    if (c.substring(c.length - 2) !== '*/') throw new EvalError(`Multi-line comments not supported in parsed parameter definitions, line:${lineNum}`, 'code', lineNum)
+    c = c.substring(2, c.length - 2).trim()
+  }
+
+  return c
+}
+
+const parseComment = (comment, lineNum, paramName) => {
+  comment = extractTextFromComment(comment, lineNum)
+
+  const ret = {}
+  const idx = comment.indexOf('{')
+  if (idx !== -1) {
+    try {
+      ret.options = JSON5.parse(comment.substring(idx))
+    } catch (e) {
+      throw new EvalError(`${e.message}, parameter:${paramName}, line:${lineNum}: ${comment.substring(idx)}`, 'code', lineNum)
+    }
+    comment = comment.substring(0, idx).trim()
+  }
+
+  ret.caption = comment
+
+  return ret
+}
+
+const parseDef = (code, line) => {
+  if (code[code.length - 1] === ',') code = code.substring(0, code.length - 1).trim()
+  let idx = code.indexOf('=')
+
+  if (idx === -1) idx = code.indexOf(':')
+
+  if (idx === -1) {
+    return { name: code, type: 'text' }
+  } else {
+    const initial = code.substring(idx + 1).trim()
+
+    const ret = { type: 'text', name: code.substring(0, idx).trim() }
+
+    if (initial === 'true' || initial === 'false') {
+      ret.type = 'checkbox'
+      ret.checked = initial === 'true'
+    } else if (/^[0-9]+$/.test(initial)) {
+      ret.type = 'int'
+      ret.initial = parseFloat(initial)
+    } else if (/^[0-9]+\.[0-9]+$/.test(initial)) {
+      ret.type = 'number'
+      ret.initial = parseFloat(initial)
+    } else {
+      try {
+        ret.initial = JSON5.parse(initial)
+      } catch (e) {
+        throw new EvalError(`Error in the initial value definition for ${code}  ${e.message}, line:${line}`, 'code', line)
+      }
+    }
+
+    return ret
+  }
+}
+
+const combineParameterDefinitions = (paramDefFromSource, extraDef) => {
+  const def = [...paramDefFromSource]
+  if (extraDef) {
+    extraDef.forEach((param) => {
+      const idx = def.findIndex((p) => p.name === param.name)
+      if (idx !== -1) def[idx] = param
+      else def.push(param)
+    })
+  }
+  return def
+}
+
+module.exports = { getParameterDefinitionsFromSource, parseOne, parseComment, parseDef, combineParameterDefinitions }

package/src/parameters/getParameterDefinitionsFromSource.test.js

@@ -0,0 +1,228 @@
+'use strict'
+const test = require('ava')
+
+const { getParameterDefinitionsFromSource, parseOne, parseComment, parseDef } = require('./getParameterDefinitionsFromSource.js')
+
+const sampleParams = [
+  { name: 'width', caption: 'Width', type: 'int', initial: 145 },
+  { name: 'height', caption: 'height', type: 'int', initial: 100 },
+  { name: 'division', caption: 'Number of rows (== columns)', type: 'int', initial: 4 },
+  { name: 'bottomPieceHeight', caption: 'Water space(mm)', type: 'int', initial: 20 },
+
+  { name: 'group1', caption: 'Wall thickness', type: 'group' },
+  { name: 'thickOut', caption: 'Vertical outside', type: 'number', initial: 0.8 },
+  { name: 'thickIn', caption: 'Vertical inside', type: 'number', initial: 0.8 },
+  { name: 'thickBottom', caption: 'Bottom', type: 'number', initial: 0.8 }
+]
+
+const sampleScript = `function main({// @jscad-params
+  width=145, // Width
+  height=100,
+  division=4,// Number of rows (== columns)
+  bottomPieceHeight=20,// Water space(mm)
+
+/* Wall thickness {name:'group1'} */
+  thickOut=0.8, //Vertical outside
+  
+  thickIn=0.8,// Vertical inside
+  thickBottom=0.8,//Bottom
+}){`
+
+const sampleScript2 = `function main({// @jscad-params
+  width=145,            // Width 
+  height=100,           // height
+  division=4,           // Number of rows (== columns)
+  bottomPieceHeight=20, // Water space(mm)
+
+// Wall thickness {name:'group1'}
+  thickOut=0.8,    // Vertical outside
+  thickIn=0.8,     // Vertical inside
+  thickBottom=0.8, // Bottom
+})`
+
+const inputTest = `const jscad = require('@jscad...');
+
+var x = 1
+
+${sampleScript}
+  var a = 1
+
+  return circle()
+}
+`
+
+test('multiple params', (t) => {
+  t.deepEqual(getParameterDefinitionsFromSource(inputTest), sampleParams)
+})
+
+test('CURRENT multiple params', (t) => {
+  t.deepEqual(getParameterDefinitionsFromSource(sampleScript2), sampleParams)
+})
+
+test('line comment', (t) => {
+  t.deepEqual(parseComment('// Width '), { caption: 'Width' })
+})
+
+test('block comment', (t) => {
+  t.deepEqual(parseComment('/* Width */'), { caption: 'Width' })
+})
+
+test('comment with data', (t) => {
+  t.deepEqual(parseComment('/* Password {type:"password"}*/'), { caption: 'Password', options: { type: 'password' } })
+})
+
+test('param without init value', (t) => {
+  t.deepEqual(parseDef('width'), { name: 'width', type: 'text' })
+})
+
+test('param int', (t) => {
+  t.deepEqual(parseDef('age=1,'), { name: 'age', type: 'int', initial: 1 })
+})
+
+test('param float', (t) => {
+  t.deepEqual(parseDef('angle=1.0,'), { name: 'angle', type: 'number', initial: 1 })
+})
+
+test('proeprty float', (t) => {
+  t.deepEqual(parseDef('angle:1.0,'), { name: 'angle', type: 'number', initial: 1 })
+})
+
+test('param checkbox', (t) => {
+  t.deepEqual(parseDef('bigorsmall=true,'), { name: 'bigorsmall', type: 'checkbox', checked: true })
+  t.deepEqual(parseDef('bigorsmall=false,'), { name: 'bigorsmall', type: 'checkbox', checked: false })
+})
+
+test('param text', (t) => {
+  t.deepEqual(parseDef('name,'), { name: 'name', type: 'text' })
+})
+
+const testBothDir = function (t, line1, line2, def) {
+  t.deepEqual(parseOne(line1, line2), def)
+}
+
+test('param checkbox with initial value', (t) => {
+  testBothDir(t,
+    '// Big? {type:"checkbox"}',
+    'bigorsmall=20,',
+    { name: 'bigorsmall', type: 'checkbox', checked: true, initial: 20, caption: 'Big?' }
+  )
+})
+
+test('param color', (t) => {
+  testBothDir(t,
+    '// Color? {type:"color"}',
+    'color=\'#FFB431\'',
+    { name: 'color', type: 'color', initial: '#FFB431', caption: 'Color?' }
+  )
+})
+
+test('param date', (t) => {
+  testBothDir(t,
+    '// Birthday? {type:"date"}',
+    'birthday',
+    { name: 'birthday', type: 'date', caption: 'Birthday?' }
+  )
+})
+
+test('param email', (t) => {
+  testBothDir(t,
+    '// Email Address? {type:"email"}',
+    'address',
+    { name: 'address', type: 'email', caption: 'Email Address?' }
+  )
+})
+
+test('param password', (t) => {
+  testBothDir(t,
+    '// Secret? {type:"password"}',
+    'password',
+    { name: 'password', type: 'password', caption: 'Secret?' }
+  )
+})
+
+test('param slider', (t) => {
+  testBothDir(t,
+    '// How many? {type:"slider", min:2, max:10}',
+    'count',
+    { name: 'count', type: 'slider', min: 2, max: 10, caption: 'How many?' }
+  )
+})
+
+test('param slider2', (t) => {
+  testBothDir(t,
+    '// How many? {type:"slider", min:2, max:10, step:2}',
+    'count',
+    { name: 'count', type: 'slider', min: 2, max: 10, step: 2, caption: 'How many?' }
+  )
+})
+
+test('param url', (t) => {
+  testBothDir(t,
+    '// Web page URL? {type:"url"}',
+    'webpage',
+    { name: 'webpage', type: 'url', caption: 'Web page URL?' }
+  )
+})
+
+test('param choice', (t) => {
+  testBothDir(t,
+    '// Rounded edges {type:\'choice\', values: [0, 1], captions: [\'No\', \'Yes (slow!)\']}',
+    'rounded=0',
+    { name: 'rounded', type: 'choice', caption: 'Rounded edges', values: [0, 1], captions: ['No', 'Yes (slow!)'], initial: 0 }
+  )
+})
+
+const sampleParamsWithHints = [
+  { name: 'width', caption: 'Width', type: 'int', initial: 145, hint: 'Width of the complete model\nIncluding other stuff' },
+  { name: 'height', caption: 'height', type: 'int', initial: 100, hint: 'Height of the complete model' },
+
+  { name: '_group_1', caption: 'Wall thickness :group1', type: 'group', hint: 'Extra description of the group so group name can stay short', initial: 'closed' },
+  { name: 'thickOut', caption: 'Vertical outside', type: 'number', initial: 0.8 }
+]
+
+const sampleScriptHints = `function main({// @jscad-params
+  width=145,    // Width 
+                // Width of the complete model
+                // Including other stuff  
+
+  height=100,   // height
+                // Height of the complete model
+
+// > Wall thickness :group1
+// Extra description of the group so group name can stay short
+  thickOut=0.8,    // Vertical outside
+})`
+
+const inputTestHints = `const jscad = require('@jscad...');
+
+var x = 1
+
+${sampleScriptHints}
+  var a = 1
+
+  return circle()
+}
+`
+
+test('extra hints', (t) => {
+  t.deepEqual(getParameterDefinitionsFromSource(inputTestHints), sampleParamsWithHints)
+})
+
+const sampleParams2 = [{ name: 'width', caption: 'width', type: 'int', initial: 14 }]
+
+test('last param brackets', (t) => {
+  t.deepEqual(getParameterDefinitionsFromSource(`function main({//@jscad-params
+  width=14})`), sampleParams2)
+})
+
+test('multiline error', (t) => {
+  t.throws(() => getParameterDefinitionsFromSource(`function main({//@jscad-params
+  /*
+  width=14})`), { instanceOf: EvalError, message: 'Multi-line comments not supported in parsed parameter definitions, line:2' })
+})
+
+test('single line /* ...*/ ok', (t) => {
+  t.deepEqual(getParameterDefinitionsFromSource(`function main({//@jscad-params
+  /* group */
+  width=14})`), [{type:'group', caption:'group', name:'_group_1'},...sampleParams2])
+})