@jbroll/jscad-modeling 2.12.7

package/benchmarks/run.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * Simple benchmark runner for @jscad/modeling
+ *
+ * Usage:
+ *   npm run bench              # run all benchmarks
+ *   npm run bench booleans     # run specific benchmark file
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+// Benchmark configuration
+const WARMUP_RUNS = 2
+const BENCHMARK_RUNS = 10
+
+/**
+ * Calculate median of an array of numbers
+ */
+const median = (arr) => {
+  const sorted = [...arr].sort((a, b) => a - b)
+  const mid = Math.floor(sorted.length / 2)
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
+}
+
+/**
+ * Run a single benchmark
+ */
+const runBenchmark = (fn, runs = BENCHMARK_RUNS) => {
+  // Warmup
+  for (let i = 0; i < WARMUP_RUNS; i++) {
+    fn()
+  }
+
+  // Force GC if available
+  if (global.gc) global.gc()
+
+  // Timed runs
+  const times = []
+  for (let i = 0; i < runs; i++) {
+    const start = process.hrtime.bigint()
+    fn()
+    const end = process.hrtime.bigint()
+    times.push(Number(end - start) / 1e6) // Convert to ms
+  }
+
+  return {
+    median: median(times),
+    min: Math.min(...times),
+    max: Math.max(...times),
+    runs
+  }
+}
+
+/**
+ * Format time with appropriate unit
+ */
+const formatTime = (ms) => {
+  if (ms < 1) return `${(ms * 1000).toFixed(1)} µs`
+  if (ms < 1000) return `${ms.toFixed(2)} ms`
+  return `${(ms / 1000).toFixed(2)} s`
+}
+
+/**
+ * Run a benchmark suite (array of {name, fn} objects)
+ */
+const runSuite = (name, benchmarks) => {
+  console.log(`\n${name}`)
+  console.log('─'.repeat(60))
+
+  const results = []
+  for (const bench of benchmarks) {
+    process.stdout.write(`  ${bench.name.padEnd(40)}`)
+    try {
+      const result = runBenchmark(bench.fn)
+      const opsPerSec = (1000 / result.median).toFixed(1)
+      console.log(`${formatTime(result.median).padStart(10)}  (${opsPerSec} ops/sec)`)
+      results.push({ name: bench.name, ...result })
+    } catch (err) {
+      console.log(`  ERROR: ${err.message}`)
+      results.push({ name: bench.name, error: err.message })
+    }
+  }
+
+  return results
+}
+
+/**
+ * Load and run benchmark files
+ */
+const main = () => {
+  const args = process.argv.slice(2)
+  const benchDir = __dirname
+
+  console.log('@jscad/modeling benchmarks')
+  console.log(`Runs: ${BENCHMARK_RUNS} (+ ${WARMUP_RUNS} warmup)`)
+  if (!global.gc) {
+    console.log('Tip: Run with --expose-gc for more accurate results')
+  }
+
+  // Find benchmark files
+  let benchFiles
+  if (args.length > 0) {
+    // Run specific benchmarks
+    benchFiles = args.map((arg) => {
+      const file = arg.endsWith('.bench.js') ? arg : `${arg}.bench.js`
+      return path.join(benchDir, file)
+    })
+  } else {
+    // Run all benchmarks
+    benchFiles = fs.readdirSync(benchDir)
+      .filter((f) => f.endsWith('.bench.js'))
+      .map((f) => path.join(benchDir, f))
+  }
+
+  // Run each benchmark file
+  const allResults = {}
+  for (const file of benchFiles) {
+    if (!fs.existsSync(file)) {
+      console.error(`Benchmark file not found: ${file}`)
+      continue
+    }
+
+    const suite = require(file)
+    if (typeof suite.run === 'function') {
+      const results = suite.run(runSuite)
+      allResults[path.basename(file)] = results
+    } else if (Array.isArray(suite.benchmarks)) {
+      const name = suite.name || path.basename(file, '.bench.js')
+      const results = runSuite(name, suite.benchmarks)
+      allResults[name] = results
+    }
+  }
+
+  console.log('\n' + '═'.repeat(60))
+  console.log('Benchmark complete')
+}
+
+// Export for programmatic use
+module.exports = { runBenchmark, runSuite, median, formatTime }
+
+// Run if called directly
+if (require.main === module) {
+  main()
+}

package/benchmarks/transforms.bench.js

@@ -0,0 +1,106 @@
+/**
+ * Transform operation benchmarks
+ *
+ * Tests translate, rotate, scale on geometries of varying complexity.
+ * These benchmarks also test the flatten utility indirectly (issue #1422).
+ */
+
+const { primitives, transforms } = require('../src')
+const { sphere, cube } = primitives
+const { translate, rotate, scale, center, align } = transforms
+
+const name = 'Transforms'
+
+// Pre-create geometries of varying complexity
+const smallGeom = () => cube({ size: 2 })
+const mediumGeom = () => sphere({ radius: 2, segments: 32 })
+const largeGeom = () => sphere({ radius: 2, segments: 64 })
+
+const benchmarks = [
+  // Single transforms
+  {
+    name: 'translate-small',
+    fn: () => translate([10, 20, 30], smallGeom())
+  },
+  {
+    name: 'translate-medium',
+    fn: () => translate([10, 20, 30], mediumGeom())
+  },
+  {
+    name: 'translate-large',
+    fn: () => translate([10, 20, 30], largeGeom())
+  },
+
+  {
+    name: 'rotate-small',
+    fn: () => rotate([Math.PI / 4, Math.PI / 3, Math.PI / 6], smallGeom())
+  },
+  {
+    name: 'rotate-medium',
+    fn: () => rotate([Math.PI / 4, Math.PI / 3, Math.PI / 6], mediumGeom())
+  },
+  {
+    name: 'rotate-large',
+    fn: () => rotate([Math.PI / 4, Math.PI / 3, Math.PI / 6], largeGeom())
+  },
+
+  {
+    name: 'scale-medium',
+    fn: () => scale([2, 3, 4], mediumGeom())
+  },
+
+  // Center and align (use measureBoundingBox internally - issue #1427)
+  {
+    name: 'center-medium',
+    fn: () => center({ axes: [true, true, true] }, mediumGeom())
+  },
+  {
+    name: 'center-large',
+    fn: () => center({ axes: [true, true, true] }, largeGeom())
+  },
+
+  {
+    name: 'align-medium',
+    fn: () => align({ modes: ['center', 'min', 'max'] }, mediumGeom())
+  },
+
+  // Transform multiple geometries (tests flatten - issue #1422)
+  {
+    name: 'translate-10-cubes',
+    fn: () => {
+      const cubes = []
+      for (let i = 0; i < 10; i++) {
+        cubes.push(cube({ size: 1, center: [i * 2, 0, 0] }))
+      }
+      return translate([5, 5, 5], cubes)
+    }
+  },
+  {
+    name: 'translate-50-cubes',
+    fn: () => {
+      const cubes = []
+      for (let i = 0; i < 50; i++) {
+        cubes.push(cube({ size: 1, center: [i * 2, 0, 0] }))
+      }
+      return translate([5, 5, 5], cubes)
+    }
+  },
+  {
+    name: 'translate-100-cubes',
+    fn: () => {
+      const cubes = []
+      for (let i = 0; i < 100; i++) {
+        cubes.push(cube({ size: 1, center: [i * 2, 0, 0] }))
+      }
+      return translate([5, 5, 5], cubes)
+    }
+  },
+
+  // Chained transforms
+  {
+    name: 'chain-translate-rotate-scale',
+    fn: () => scale([2, 2, 2], rotate([0, Math.PI / 4, 0], translate([5, 0, 0], mediumGeom())))
+  }
+]
+
+module.exports = { name, benchmarks }

package/benchmarks/utils.bench.js

@@ -0,0 +1,89 @@
+/**
+ * Utility function benchmarks
+ *
+ * Tests flatten and other utilities.
+ * These benchmarks target issue #1422 (inefficient flatten with recursive concat).
+ */
+
+const { utils } = require('../src')
+const { flatten } = utils
+
+const name = 'Utils'
+
+// Create nested arrays of varying depth and size
+const createNestedArray = (depth, itemsPerLevel) => {
+  if (depth === 0) return [1, 2, 3]
+  const result = []
+  for (let i = 0; i < itemsPerLevel; i++) {
+    result.push(createNestedArray(depth - 1, itemsPerLevel))
+  }
+  return result
+}
+
+// Create flat array with many items
+const createFlatArray = (size) => {
+  const result = []
+  for (let i = 0; i < size; i++) {
+    result.push({ id: i })
+  }
+  return result
+}
+
+// Create mixed nested/flat array (realistic usage)
+const createMixedArray = (groups, itemsPerGroup) => {
+  const result = []
+  for (let i = 0; i < groups; i++) {
+    const group = []
+    for (let j = 0; j < itemsPerGroup; j++) {
+      group.push({ id: i * itemsPerGroup + j })
+    }
+    result.push(group)
+  }
+  return result
+}
+
+const benchmarks = [
+  // Flat arrays (no nesting needed)
+  {
+    name: 'flatten-flat-10-items',
+    fn: () => flatten(createFlatArray(10))
+  },
+  {
+    name: 'flatten-flat-100-items',
+    fn: () => flatten(createFlatArray(100))
+  },
+  {
+    name: 'flatten-flat-1000-items',
+    fn: () => flatten(createFlatArray(1000))
+  },
+
+  // Mixed arrays (typical usage: arrays of geometry arrays)
+  {
+    name: 'flatten-mixed-10x10',
+    fn: () => flatten(createMixedArray(10, 10))
+  },
+  {
+    name: 'flatten-mixed-20x20',
+    fn: () => flatten(createMixedArray(20, 20))
+  },
+  {
+    name: 'flatten-mixed-50x10',
+    fn: () => flatten(createMixedArray(50, 10))
+  },
+
+  // Deeply nested (stress test)
+  {
+    name: 'flatten-nested-depth-3',
+    fn: () => flatten(createNestedArray(3, 4))
+  },
+  {
+    name: 'flatten-nested-depth-4',
+    fn: () => flatten(createNestedArray(4, 3))
+  },
+  {
+    name: 'flatten-nested-depth-5',
+    fn: () => flatten(createNestedArray(5, 2))
+  }
+]
+
+module.exports = { name, benchmarks }