@jscad/modeling 2.12.5 → 3.0.1-alpha.0

package/src/maths/plane/fromNoisyPoints.js

@@ -1,106 +0,0 @@
-const vec3 = require('../vec3')
-const fromNormalAndPoint = require('./fromNormalAndPoint')
-
-/**
- * Create a best-fit plane from the given noisy vertices.
- *
- * NOTE: There are two possible orientations for every plane.
- *       This function always produces positive orientations.
- *
- * See http://www.ilikebigbits.com for the original discussion
- *
- * @param {Plane} out - receiving plane
- * @param {Array} vertices - list of vertices in any order or position
- * @returns {Plane} out
- * @alias module:modeling/maths/plane.fromNoisyPoints
- */
-const fromNoisyPoints = (out, ...vertices) => {
-  out[0] = 0.0
-  out[1] = 0.0
-  out[2] = 0.0
-  out[3] = 0.0
-
-  // calculate the centroid of the vertices
-  // NOTE: out is the centriod
-  const n = vertices.length
-  vertices.forEach((v) => {
-    vec3.add(out, out, v)
-  })
-  vec3.scale(out, out, 1.0 / n)
-
-  // Calculate full 3x3 covariance matrix, excluding symmetries
-  let xx = 0.0
-  let xy = 0.0
-  let xz = 0.0
-  let yy = 0.0
-  let yz = 0.0
-  let zz = 0.0
-
-  const vn = vec3.create()
-  vertices.forEach((v) => {
-    // NOTE: out is the centriod
-    vec3.subtract(vn, v, out)
-    xx += vn[0] * vn[0]
-    xy += vn[0] * vn[1]
-    xz += vn[0] * vn[2]
-    yy += vn[1] * vn[1]
-    yz += vn[1] * vn[2]
-    zz += vn[2] * vn[2]
-  })
-
-  xx /= n
-  xy /= n
-  xz /= n
-  yy /= n
-  yz /= n
-  zz /= n
-
-  // Calculate the smallest Eigenvector of the covariance matrix
-  // which becomes the plane normal
-
-  vn[0] = 0.0
-  vn[1] = 0.0
-  vn[2] = 0.0
-
-  // weighted directional vector
-  const wdv = vec3.create()
-
-  // X axis
-  let det = yy * zz - yz * yz
-  wdv[0] = det
-  wdv[1] = xz * yz - xy * zz
-  wdv[2] = xy * yz - xz * yy
-
-  let weight = det * det
-  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
-
-  // Y axis
-  det = xx * zz - xz * xz
-  wdv[0] = xz * yz - xy * zz
-  wdv[1] = det
-  wdv[2] = xy * xz - yz * xx
-
-  weight = det * det
-  if (vec3.dot(vn, wdv) < 0.0) {
-    weight = -weight
-  }
-  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
-
-  // Z axis
-  det = xx * yy - xy * xy
-  wdv[0] = xy * yz - xz * yy
-  wdv[1] = xy * xz - yz * xx
-  wdv[2] = det
-
-  weight = det * det
-  if (vec3.dot(vn, wdv) < 0.0) {
-    weight = -weight
-  }
-  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
-
-  // create the plane from normal and centriod
-  // NOTE: out is the centriod
-  return fromNormalAndPoint(out, vn, out)
-}
-
-module.exports = fromNoisyPoints

package/src/maths/plane/fromNoisyPoints.test.js

@@ -1,24 +0,0 @@
-const test = require('ava')
-const { fromNoisyPoints, create } = require('./index')
-
-const { compareVectors } = require('../../../test/helpers/index')
-
-test('plane: fromNoisyPoints() should return a new plane with correct values', (t) => {
-  const obs1 = fromNoisyPoints(create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
-  t.true(compareVectors(obs1, [0, 0, 1, 0]))
-
-  const obs2 = fromNoisyPoints(obs1, [0, 6, 0], [0, 2, 2], [0, 6, 6])
-  t.true(compareVectors(obs2, [1, 0, 0, 0]))
-
-  // same vertices results in an invalid plane
-  const obs3 = fromNoisyPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
-  t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
-
-  // co-linear vertices
-  const obs4 = fromNoisyPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
-  t.true(compareVectors(obs4, [0, 0, 1, 0]))
-
-  // random vertices
-  const obs5 = fromNoisyPoints(obs1, [0, 0, 0], [5, 1, -2], [3, -2, 4], [1, 1, 0])
-  t.true(compareVectors(obs5, [0.08054818365229491, 0.8764542170444571, 0.47469990050062555, 0.4185833634679763]))
-})

package/src/maths/utils/index.d.ts

@@ -1,8 +0,0 @@
-export { default as aboutEqualNormals } from './aboutEqualNormals'
-export { default as area } from './area'
-export { default as interpolateBetween2DPointsForY } from './interpolateBetween2DPointsForY'
-export { default as intersect } from './intersect'
-export { default as solve2Linear } from './solve2Linear'
-export { sin, cos } from './trigonometry'
-
-export as namespace utils

package/src/maths/utils/index.js

@@ -1,15 +0,0 @@
-/**
- * Utility functions for maths.
- * @module modeling/maths/utils
- * @example
- * const { area, solve2Linear } = require('@jscad/maths').utils
- */
-module.exports = {
-  aboutEqualNormals: require('./aboutEqualNormals'),
-  area: require('./area'),
-  cos: require('./trigonometry').cos,
-  interpolateBetween2DPointsForY: require('./interpolateBetween2DPointsForY'),
-  intersect: require('./intersect'),
-  sin: require('./trigonometry').sin,
-  solve2Linear: require('./solve2Linear')
-}

package/src/operations/booleans/fromFakePolygons.js

@@ -1,52 +0,0 @@
-const vec2 = require('../../maths/vec2')
-
-const geom2 = require('../../geometries/geom2')
-
-const fromFakePolygon = (epsilon, polygon) => {
-  // this can happen based on union, seems to be residuals -
-  // return null and handle in caller
-  if (polygon.vertices.length < 4) {
-    return null
-  }
-  const vert1Indices = []
-  const points3D = polygon.vertices.filter((vertex, i) => {
-    if (vertex[2] > 0) {
-      vert1Indices.push(i)
-      return true
-    }
-    return false
-  })
-
-  if (points3D.length !== 2) {
-    throw new Error('Assertion failed: fromFakePolygon: not enough points found') // TBD remove later
-  }
-
-  const points2D = points3D.map((v3) => {
-    const x = Math.round(v3[0] / epsilon) * epsilon + 0 // no more -0
-    const y = Math.round(v3[1] / epsilon) * epsilon + 0 // no more -0
-    return vec2.fromValues(x, y)
-  })
-
-  if (vec2.equals(points2D[0], points2D[1])) return null
-
-  const d = vert1Indices[1] - vert1Indices[0]
-  if (d === 1 || d === 3) {
-    if (d === 1) {
-      points2D.reverse()
-    }
-  } else {
-    throw new Error('Assertion failed: fromFakePolygon: unknown index ordering')
-  }
-  return points2D
-}
-
-/*
- * Convert the given polygons to a list of sides.
- * The polygons must have only z coordinates +1 and -1, as constructed by to3DWalls().
- */
-const fromFakePolygons = (epsilon, polygons) => {
-  const sides = polygons.map((polygon) => fromFakePolygon(epsilon, polygon)).filter((polygon) => (polygon !== null))
-  return geom2.create(sides)
-}
-
-module.exports = fromFakePolygons

package/src/operations/booleans/to3DWalls.js

@@ -1,36 +0,0 @@
-const vec3 = require('../../maths/vec3')
-
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
-
-/*
- * Create a polygon (wall) from the given Z values and side.
- */
-const to3DWall = (z0, z1, side) => {
-  const points = [
-    vec3.fromVec2(vec3.create(), side[0], z0),
-    vec3.fromVec2(vec3.create(), side[1], z0),
-    vec3.fromVec2(vec3.create(), side[1], z1),
-    vec3.fromVec2(vec3.create(), side[0], z1)
-  ]
-  return poly3.create(points)
-}
-
-/*
- * Create a 3D geometry with walls, as constructed from the given options and geometry.
- *
- * @param {Object} options - options with Z offsets
- * @param {geom2} geometry - geometry used as base of walls
- * @return {geom3} the new geometry
- */
-const to3DWalls = (options, geometry) => {
-  const sides = geom2.toSides(geometry)
-
-  const polygons = sides.map((side) => to3DWall(options.z0, options.z1, side))
-
-  const result = geom3.create(polygons)
-  return result
-}
-
-module.exports = to3DWalls

package/src/operations/expansions/expand.d.ts

@@ -1,18 +0,0 @@
-import { Path2, Geom2, Geom3 } from '../../geometries/types'
-import { Corners } from '../../utils/corners'
-import RecursiveArray from '../../utils/recursiveArray'
-
-export default expand
-
-export interface ExpandOptions {
-  delta?: number
-  corners?: Corners
-  segments?: number
-}
-
-type Geom = Path2 | Geom2 | Geom3
-
-declare function expand(options: ExpandOptions, geometry: Path2 | Geom2): Geom2
-declare function expand(options: ExpandOptions, geometry: Geom3): Geom3
-declare function expand<T extends Geom>(options?: ExpandOptions, ...geometries: RecursiveArray<T>): Array<T>
-declare function expand(options?: ExpandOptions, ...geometries: RecursiveArray<Geom>): Array<Geom>

package/src/operations/expansions/expand.js

@@ -1,42 +0,0 @@
-const flatten = require('../../utils/flatten')
-
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
-
-const expandGeom2 = require('./expandGeom2')
-const expandGeom3 = require('./expandGeom3')
-const expandPath2 = require('./expandPath2')
-
-/**
- * Expand the given geometry using the given options.
- * Both internal and external space is expanded for 2D and 3D shapes.
- *
- * Note: Contract is expand using a negative delta.
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+/-) of expansion
- * @param {String} [options.corners='edge'] - type of corner to create after expanding; edge, chamfer, round
- * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {...Objects} objects - the geometries to expand
- * @return {Object|Array} new geometry, or list of new geometries
- * @alias module:modeling/expansions.expand
- *
- * @example
- * let newarc = expand({delta: 5, corners: 'edge'}, arc({}))
- * let newsquare = expand({delta: 5, corners: 'chamfer'}, square({size: 30}))
- * let newcuboid = expand({delta: 2, corners: 'round'}, cuboid({size: [20, 25, 5]}))
- */
-const expand = (options, ...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
-  const results = objects.map((object) => {
-    if (path2.isA(object)) return expandPath2(options, object)
-    if (geom2.isA(object)) return expandGeom2(options, object)
-    if (geom3.isA(object)) return expandGeom3(options, object)
-    return object
-  })
-  return results.length === 1 ? results[0] : results
-}
-
-module.exports = expand

package/src/operations/expansions/expand.test.js

@@ -1,188 +0,0 @@
-const test = require('ava')
-
-const { comparePoints, nearlyEqual } = require('../../../test/helpers')
-
-const { geom2, geom3, path2 } = require('../../geometries')
-const measureBoundingBox = require('../../measurements/measureBoundingBox')
-const area = require('../../maths/utils/area')
-const { TAU } = require('../../maths/constants')
-const sphere = require('../../primitives/sphere')
-
-const { expand } = require('./index')
-
-test('expand: edge-expanding a straight line produces rectangle', (t) => {
-  const points = [[0, 0], [0, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 40)
-  t.true(comparePoints(measureBoundingBox(expandedPathGeom2), [[-2, 0, 0], [2, 10, 0]]))
-})
-
-test('expand: edge-expanding a bent line produces expected geometry', (t) => {
-  const points = [[0, 0], [0, 10], [-5, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 60)
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: edge-expanding a bent line, reversed points, produces expected geometry', (t) => {
-  const points = [[-5, 10], [0, 10], [0, 0]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 60)
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: round-expanding a bent line produces expected geometry', (t) => {
-  const delta = 2
-  const points = [[0, 0], [0, 10], [-5, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta, corners: 'round', segments: 128 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  const expectedArea = 56 + TAU * delta * 1.25 // shape will have 1 and 1/4 circles
-  nearlyEqual(t, area(expandedPoints), expectedArea, 0.01, 'Measured area should be pretty close')
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-7, -2, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: chamfer-expanding a bent line produces expected geometry', (t) => {
-  const delta = 2
-  const points = [[0, 0], [0, 10], [-5, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta, corners: 'chamfer', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 58)
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: expanding of a geom2 produces expected changes to points', (t) => {
-  const geometry = geom2.fromPoints([[-8, -8], [8, -8], [8, 8], [-8, 8]])
-
-  const obs = expand({ delta: 2, corners: 'round', segments: 8 }, geometry)
-  const pts = geom2.toPoints(obs)
-  const exp = [
-    [-9.414213562373096, -9.414213562373096],
-    [-8, -10],
-    [8, -10],
-    [9.414213562373096, -9.414213562373096],
-    [10, -8],
-    [10, 8],
-    [9.414213562373096, 9.414213562373096],
-    [8, 10],
-    [-8, 10],
-    [-9.414213562373096, 9.414213562373096],
-    [-10, 8],
-    [-10, -8]
-  ]
-  t.notThrows(() => geom2.validate(obs))
-  t.is(pts.length, 12)
-  t.true(comparePoints(pts, exp))
-})
-
-test('expand: expanding of a geom3 produces expected changes to polygons', (t) => {
-  const polygonsAsPoints = [
-    [[-5, -5, -5], [-5, -5, 15], [-5, 15, 15], [-5, 15, -5]],
-    [[15, -5, -5], [15, 15, -5], [15, 15, 15], [15, -5, 15]],
-    [[-5, -5, -5], [15, -5, -5], [15, -5, 15], [-5, -5, 15]],
-    [[-5, 15, -5], [-5, 15, 15], [15, 15, 15], [15, 15, -5]],
-    [[-5, -5, -5], [-5, 15, -5], [15, 15, -5], [15, -5, -5]],
-    [[-5, -5, 15], [15, -5, 15], [15, 15, 15], [-5, 15, 15]]
-  ]
-  const geometry = geom3.fromPoints(polygonsAsPoints)
-
-  const obs = expand({ delta: 2, corners: 'round', segments: 8 }, geometry)
-  const pts = geom3.toPoints(obs)
-  const exp0 = [
-    [-7, -5, -5],
-    [-7, -5, 15],
-    [-7, 15, 15],
-    [-7, 15, -5]
-  ]
-  const exp61 = [
-    [15, -7, 15],
-    [16.414213562373096, -6.414213562373095, 15],
-    [16, -6.414213562373095, 16]
-  ]
-
-  t.notThrows.skip(() => geom3.validate(obs))
-  t.is(pts.length, 62)
-  t.true(comparePoints(pts[0], exp0))
-  t.true(comparePoints(pts[61], exp61))
-
-  const geometry2 = sphere({ radius: 5, segments: 8 })
-  const obs2 = expand({ delta: 5 }, geometry2)
-  const pts2 = geom3.toPoints(obs2)
-  t.notThrows.skip(() => geom3.validate(obs2))
-  t.is(pts2.length, 864)
-})
-
-test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
-  const geometry = geom2.create([
-    [[-75, 75], [-75, -75]],
-    [[-75, -75], [75, -75]],
-    [[75, -75], [75, 75]],
-    [[-40, 75], [-75, 75]],
-    [[75, 75], [40, 75]],
-    [[40, 75], [40, 0]],
-    [[40, 0], [-40, 0]],
-    [[-40, 0], [-40, 75]],
-    [[15, -10], [15, -40]],
-    [[-15, -10], [15, -10]],
-    [[-15, -40], [-15, -10]],
-    [[-8, -40], [-15, -40]],
-    [[15, -40], [8, -40]],
-    [[-8, -25], [-8, -40]],
-    [[8, -25], [-8, -25]],
-    [[8, -40], [8, -25]],
-    [[-2, -15], [-2, -19]],
-    [[-2, -19], [2, -19]],
-    [[2, -19], [2, -15]],
-    [[2, -15], [-2, -15]]
-  ])
-
-  // expand +
-  const obs = expand({ delta: 2, corners: 'edge' }, geometry)
-  const pts = geom2.toPoints(obs)
-  const exp = [
-    [77, -77],
-    [77, 77],
-    [38, 77],
-    [38, 2],
-    [-38, 2],
-    [-37.99999999999999, 77],
-    [-77, 77],
-    [16.999999999999996, -42],
-    [6, -42],
-    [6, -27],
-    [-6, -27],
-    [-6.000000000000001, -42],
-    [-17, -42],
-    [-16.999999999999996, -8],
-    [17, -8.000000000000004],
-    [-4, -21],
-    [3.9999999999999996, -21],
-    [4, -13],
-    [-4, -13],
-    [-77, -77]
-  ]
-  t.notThrows(() => geom2.validate(obs))
-  t.is(pts.length, 20)
-  t.true(comparePoints(pts, exp))
-})

package/src/operations/expansions/expandGeom2.js

@@ -1,43 +0,0 @@
-const geom2 = require('../../geometries/geom2')
-
-const offsetFromPoints = require('./offsetFromPoints')
-
-/*
- * Expand the given geometry (geom2) using the given options (if any).
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+/-) of expansion
- * @param {String} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
- * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {geom2} geometry - the geometry to expand
- * @returns {geom2} expanded geometry
- */
-const expandGeom2 = (options, geometry) => {
-  const defaults = {
-    delta: 1,
-    corners: 'edge',
-    segments: 16
-  }
-  const { delta, corners, segments } = Object.assign({ }, defaults, options)
-
-  if (!(corners === 'edge' || corners === 'chamfer' || corners === 'round')) {
-    throw new Error('corners must be "edge", "chamfer", or "round"')
-  }
-
-  // convert the geometry to outlines, and generate offsets from each
-  const outlines = geom2.toOutlines(geometry)
-  const newoutlines = outlines.map((outline) => {
-    options = {
-      delta,
-      corners,
-      closed: true,
-      segments
-    }
-    return offsetFromPoints(options, outline)
-  })
-
-  // create a composite geometry from the new outlines
-  const allsides = newoutlines.reduce((sides, newoutline) => sides.concat(geom2.toSides(geom2.fromPoints(newoutline))), [])
-  return geom2.create(allsides)
-}
-
-module.exports = expandGeom2

package/src/operations/expansions/expandGeom3.js

@@ -1,36 +0,0 @@
-const geom3 = require('../../geometries/geom3')
-
-const union = require('../booleans/union')
-
-const expandShell = require('./expandShell')
-
-/*
- * Expand the given geometry (geom3) using the given options (if any).
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+/-) of expansion
- * @param {String} [options.corners='round'] - type corner to create during of expansion; round
- * @param {Integer} [options.segments=12] - number of segments when creating round corners
- * @param {geom3} geometry - the geometry to expand
- * @returns {geom3} expanded geometry
- */
-const expandGeom3 = (options, geometry) => {
-  const defaults = {
-    delta: 1,
-    corners: 'round',
-    segments: 12
-  }
-  const { delta, corners, segments } = Object.assign({ }, defaults, options)
-
-  if (!(corners === 'round')) {
-    throw new Error('corners must be "round" for 3D geometries')
-  }
-
-  const polygons = geom3.toPolygons(geometry)
-  if (polygons.length === 0) throw new Error('the given geometry cannot be empty')
-
-  options = { delta, corners, segments }
-  const expanded = expandShell(options, geometry)
-  return union(geometry, expanded)
-}
-
-module.exports = expandGeom3

package/src/operations/expansions/extrudePolygon.js

@@ -1,34 +0,0 @@
-const mat4 = require('../../maths/mat4')
-const vec3 = require('../../maths/vec3')
-
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
-
-// Extrude a polygon in the direction of the offsetvector.
-// Returns (geom3) a new geometry
-const extrudePolygon = (offsetvector, polygon1) => {
-  const direction = vec3.dot(poly3.plane(polygon1), offsetvector)
-  if (direction > 0) {
-    polygon1 = poly3.invert(polygon1)
-  }
-
-  const newpolygons = [polygon1]
-
-  const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1)
-  const numvertices = polygon1.vertices.length
-  for (let i = 0; i < numvertices; i++) {
-    const nexti = (i < (numvertices - 1)) ? i + 1 : 0
-    const sideFacePolygon = poly3.create([
-      polygon1.vertices[i],
-      polygon2.vertices[i],
-      polygon2.vertices[nexti],
-      polygon1.vertices[nexti]
-    ])
-    newpolygons.push(sideFacePolygon)
-  }
-  newpolygons.push(poly3.invert(polygon2))
-
-  return geom3.create(newpolygons)
-}
-
-module.exports = extrudePolygon

package/src/operations/expansions/index.d.ts

@@ -1,4 +0,0 @@
-export { default as expand, ExpandOptions } from './expand'
-export { default as offset, OffsetOptions } from './offset'
-
-export as namespace expansions

package/src/operations/expansions/index.js

@@ -1,11 +0,0 @@
-/**
- * All shapes (primitives or the results of operations) can be expanded (or contracted.)
- * In all cases, the function returns the results, and never changes the original shapes.
- * @module modeling/expansions
- * @example
- * const { expand, offset } = require('@jscad/modeling').expansions
- */
-module.exports = {
-  expand: require('./expand'),
-  offset: require('./offset')
-}

package/src/operations/expansions/offset.d.ts

@@ -1,15 +0,0 @@
-import { Path2, Geom2 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
-
-type Geometry = Path2 | Geom2
-
-export default offset
-
-export interface OffsetOptions {
-  delta?: number
-  corners?: 'edge' | 'chamfer' | 'round'
-  segments?: number
-}
-
-declare function offset<T extends Geometry>(options: OffsetOptions, geometry: T): T
-declare function offset(options?: OffsetOptions, ...geometries: RecursiveArray<Geometry>): Geometry

package/src/operations/expansions/offset.js

@@ -1,36 +0,0 @@
-const flatten = require('../../utils/flatten')
-
-const geom2 = require('../../geometries/geom2')
-const path2 = require('../../geometries/path2')
-
-const offsetGeom2 = require('./offsetGeom2')
-const offsetPath2 = require('./offsetPath2')
-
-/**
- * Create offset geometry from the given geometry using the given options.
- * Offsets from internal and external space are created.
- * @param {Object} options - options for offset
- * @param {Float} [options.delta=1] - delta of offset (+ to exterior, - from interior)
- * @param {String} [options.corners='edge'] - type of corner to create after offseting; edge, chamfer, round
- * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {...Object} objects - the geometries to offset
- * @return {Object|Array} new geometry, or list of new geometries
- * @alias module:modeling/expansions.offset
- *
- * @example
- * let small = offset({ delta: -4, corners: 'chamfer' }, square({size: 40})) // contract
- */
-const offset = (options, ...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
-  const results = objects.map((object) => {
-    if (path2.isA(object)) return offsetPath2(options, object)
-    if (geom2.isA(object)) return offsetGeom2(options, object)
-    // if (geom3.isA(object)) return geom3.transform(matrix, object)
-    return object
-  })
-  return results.length === 1 ? results[0] : results
-}
-
-module.exports = offset