@richardmcquiston01/more-open-scad 0.2.0

package/dist/io/manifold-check.d.ts

@@ -0,0 +1,20 @@
+import type { Solid } from '../geometry/solid';
+/**
+ * Checks whether `solid` is manifold ("watertight"): every directed edge
+ * produced by triangulating the solid has exactly one occurrence, and its
+ * reverse-directed counterpart also has exactly one occurrence elsewhere
+ * in the mesh. This is the standard mesh-processing definition of a
+ * closed, consistently-wound 2-manifold surface — it catches both holes
+ * (a directed edge with no matching reverse partner) and winding
+ * inconsistencies (a directed edge duplicated in the same direction,
+ * which leaves its reverse missing).
+ *
+ * A solid with no triangles is defined as manifold (`true`): there are no
+ * edges to violate the watertightness property, so the check is
+ * vacuously satisfied rather than an error condition.
+ *
+ * @param solid - The solid to check.
+ * @returns `true` if `solid` is manifold, `false` otherwise.
+ */
+export declare function isManifold(solid: Solid): boolean;
+//# sourceMappingURL=manifold-check.d.ts.map

package/dist/io/manifold-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifold-check.d.ts","sourceRoot":"","sources":["../../src/io/manifold-check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAqC/C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAsChD"}

package/dist/io/stl-ascii.d.ts

@@ -0,0 +1,14 @@
+import type { Solid } from '../geometry/solid';
+/**
+ * Serializes `solid` to the standard ASCII STL text format.
+ *
+ * `name` (default `''`) is used as the identifier on both the opening
+ * `solid` line and the closing `endsolid` line, per the STL spec — when
+ * empty, the header/footer lines are emitted as bare `solid`/`endsolid`
+ * with no trailing space. Triangles are sourced from `triangulateSolid` and
+ * emitted in order, one `facet normal` / `outer loop` / `vertex` x3 /
+ * `endloop` / `endfacet` block per triangle. The result always ends with a
+ * trailing newline.
+ */
+export declare function toASCIISTL(solid: Solid, name?: string): string;
+//# sourceMappingURL=stl-ascii.d.ts.map

package/dist/io/stl-ascii.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stl-ascii.d.ts","sourceRoot":"","sources":["../../src/io/stl-ascii.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAkC/C;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,SAAK,GAAG,MAAM,CAiB1D"}

package/dist/io/stl-binary.d.ts

@@ -0,0 +1,13 @@
+import type { Solid } from '../geometry/solid';
+/**
+ * Serializes `solid` to the binary STL file format.
+ *
+ * The output is exactly `80 + 4 + 50 * n` bytes, where `n` is the number of
+ * triangles `triangulateSolid(solid)` produces: an 80-byte header (arbitrary
+ * content, but not starting with `"solid"`), a little-endian `uint32`
+ * triangle count, then one 50-byte little-endian record per triangle (a
+ * `float32` facet normal, three `float32` vertex positions, and a `uint16`
+ * attribute byte count that is always `0`).
+ */
+export declare function toBinarySTL(solid: Solid): Uint8Array;
+//# sourceMappingURL=stl-binary.d.ts.map

package/dist/io/stl-binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stl-binary.d.ts","sourceRoot":"","sources":["../../src/io/stl-binary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAoB/C;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAqCpD"}

package/dist/io/triangulate-solid.d.ts

@@ -0,0 +1,25 @@
+import type { Solid } from '../geometry/solid';
+import type { Vec3 as Vec3Type } from '../math/vec3';
+/**
+ * A single triangle in STL's flat, per-facet representation: one normal
+ * plus three vertex positions (STL has no notion of per-vertex smooth
+ * shading, unlike `Vertex`).
+ */
+export interface StlTriangle {
+    readonly normal: Vec3Type;
+    readonly vertices: readonly [Vec3Type, Vec3Type, Vec3Type];
+}
+/**
+ * Flattens `solid` into the list of triangles STL export needs: every
+ * polygon is fan-triangulated (reusing `geometry/triangulate`), and each
+ * resulting triangle's normal is (re)computed directly from its own three
+ * vertex positions via the right-hand rule — matching STL's convention
+ * that vertices are wound counter-clockwise when viewed from the side the
+ * normal points toward. Computing the normal per-triangle (rather than
+ * reusing the source polygon's plane or a vertex's smooth-shading normal)
+ * keeps every emitted triangle self-consistent, even for a polygon whose
+ * vertices aren't perfectly planar (e.g. a caller-supplied `polyhedron`
+ * face).
+ */
+export declare function triangulateSolid(solid: Solid): StlTriangle[];
+//# sourceMappingURL=triangulate-solid.d.ts.map

package/dist/io/triangulate-solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangulate-solid.d.ts","sourceRoot":"","sources":["../../src/io/triangulate-solid.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;CAC5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,EAAE,CAW5D"}

package/dist/math/epsilon.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default tolerance used for floating-point comparisons throughout the
+ * geometry kernel (vector/matrix math, plane classification, CSG splitting).
+ */
+export declare const EPSILON = 1e-9;
+/**
+ * Returns whether `a` and `b` are equal within `tolerance`.
+ */
+export declare function almostEqual(a: number, b: number, tolerance?: number): boolean;
+//# sourceMappingURL=epsilon.d.ts.map

package/dist/math/epsilon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epsilon.d.ts","sourceRoot":"","sources":["../../src/math/epsilon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,OAAO,OAAO,CAAC;AAE5B;;GAEG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,SAAU,GAClB,OAAO,CAET"}

package/dist/math/mat4.d.ts

@@ -0,0 +1,75 @@
+import { type Vec3 } from './vec3';
+/**
+ * The 16 elements of a `Mat4`, stored **column-major** (the same layout
+ * used by OpenGL/WebGL/three.js): `e[12]`, `e[13]`, `e[14]` hold the
+ * translation. `transformPoint`/`transformDirection` apply the matrix to a
+ * column vector, i.e. `v' = M * v`.
+ */
+export type Mat4Elements = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/** An immutable 4x4 transformation matrix. */
+export interface Mat4 {
+    readonly e: Mat4Elements;
+}
+/** The identity matrix. */
+export declare const IDENTITY: Mat4;
+/** A matrix translating by `v`. */
+export declare function translation(v: Vec3): Mat4;
+/** A matrix scaling each axis by the corresponding component of `v`. */
+export declare function scaling(v: Vec3): Mat4;
+/** A matrix rotating `radians` around the X axis (right-hand rule). */
+export declare function rotationX(radians: number): Mat4;
+/** A matrix rotating `radians` around the Y axis (right-hand rule). */
+export declare function rotationY(radians: number): Mat4;
+/** A matrix rotating `radians` around the Z axis (right-hand rule). */
+export declare function rotationZ(radians: number): Mat4;
+/**
+ * A matrix rotating `radians` around `axis` (right-hand rule), via the
+ * Rodrigues rotation formula. `axis` need not be pre-normalized.
+ */
+export declare function rotationAxisAngle(axis: Vec3, radians: number): Mat4;
+/**
+ * A matrix reflecting points across the plane through the origin with
+ * (not necessarily unit) normal `normal` — the Householder reflection
+ * `I - 2 * n * nᵀ`. Reflections have determinant `-1`.
+ */
+export declare function reflection(normal: Vec3): Mat4;
+/** The matrix product `a * b` (i.e. "apply `b`, then `a`" to a point). */
+export declare function multiply(a: Mat4, b: Mat4): Mat4;
+/** The transpose of `m`. */
+export declare function transpose(m: Mat4): Mat4;
+/** The determinant of `m`. */
+export declare function determinant(m: Mat4): number;
+/**
+ * The inverse of `m`, or `null` if `m` is singular (not invertible within
+ * floating-point tolerance).
+ */
+export declare function invert(m: Mat4): Mat4 | null;
+/** Whether `a` and `b` are equal within `tolerance` on every element. */
+export declare function equals(a: Mat4, b: Mat4, tolerance?: number): boolean;
+/** Applies `m` to point `v` (treats `v` as having an implicit `w = 1`). */
+export declare function transformPoint(m: Mat4, v: Vec3): Vec3;
+/**
+ * Applies `m` to direction `v` (treats `v` as having an implicit `w = 0`,
+ * so translation is ignored). Note: transforming a *normal* correctly under
+ * non-uniform scale requires the inverse-transpose of `m`, not `m` itself —
+ * callers responsible for normals should pass `transpose(invert(m))`.
+ */
+export declare function transformDirection(m: Mat4, v: Vec3): Vec3;
+//# sourceMappingURL=mat4.d.ts.map

package/dist/math/mat4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mat4.d.ts","sourceRoot":"","sources":["../../src/math/mat4.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,QAAQ,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS;IAClC,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;CACP,CAAC;AAEF,8CAA8C;AAC9C,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;CAC1B;AAMD,2BAA2B;AAC3B,eAAO,MAAM,QAAQ,EAAE,IAErB,CAAC;AAEH,mCAAmC;AACnC,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEzC;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAErC;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI/C;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI/C;AAED,uEAAuE;AACvE,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI/C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CA8BnE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI,CA2B7C;AAED,0EAA0E;AAC1E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CA2D/C;AAED,4BAA4B;AAC5B,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAqCvC;AAwED,8BAA8B;AAC9B,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAE3C;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CA2D3C;AAED,yEAAyE;AACzE,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAU,GAAG,OAAO,CAErE;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAwBrD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAOzD"}

package/dist/math/vec3.d.ts

@@ -0,0 +1,43 @@
+/**
+ * An immutable 3-component vector (or point).
+ *
+ * `Vec3` values are treated as immutable throughout the codebase — every
+ * function below returns a new `Vec3` rather than mutating its arguments.
+ */
+export interface Vec3 {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/**
+ * Creates a `Vec3` from its components.
+ */
+export declare function vec3(x: number, y: number, z: number): Vec3;
+/** The zero vector, `(0, 0, 0)`. */
+export declare const ZERO: Vec3;
+/** Component-wise addition: `a + b`. */
+export declare function add(a: Vec3, b: Vec3): Vec3;
+/** Component-wise subtraction: `a - b`. */
+export declare function sub(a: Vec3, b: Vec3): Vec3;
+/** Scales `v` by scalar `s`. */
+export declare function scale(v: Vec3, s: number): Vec3;
+/** Negates `v`, equivalent to `scale(v, -1)`. */
+export declare function negate(v: Vec3): Vec3;
+/** The dot product of `a` and `b`. */
+export declare function dot(a: Vec3, b: Vec3): number;
+/** The cross product `a × b`, following the right-hand rule. */
+export declare function cross(a: Vec3, b: Vec3): Vec3;
+/** The Euclidean length (magnitude) of `v`. */
+export declare function length(v: Vec3): number;
+/**
+ * Returns `v` scaled to unit length.
+ *
+ * The zero vector has no defined direction, so normalizing it returns the
+ * zero vector rather than producing `NaN`.
+ */
+export declare function normalize(v: Vec3): Vec3;
+/** Linearly interpolates from `a` to `b` by `t` (0 = `a`, 1 = `b`). */
+export declare function lerp(a: Vec3, b: Vec3, t: number): Vec3;
+/** Whether `a` and `b` are equal within `tolerance` on every component. */
+export declare function equals(a: Vec3, b: Vec3, tolerance?: number): boolean;
+//# sourceMappingURL=vec3.d.ts.map

package/dist/math/vec3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vec3.d.ts","sourceRoot":"","sources":["../../src/math/vec3.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAE1D;AAED,oCAAoC;AACpC,eAAO,MAAM,IAAI,EAAE,IAAoB,CAAC;AAExC,wCAAwC;AACxC,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE1C;AAED,2CAA2C;AAC3C,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAE1C;AAED,gCAAgC;AAChC,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAE9C;AAED,iDAAiD;AACjD,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEpC;AAED,sCAAsC;AACtC,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAE5C;AAED,gEAAgE;AAChE,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAM5C;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAEtC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAMvC;AAED,uEAAuE;AACvE,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED,2EAA2E;AAC3E,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,SAAU,GAAG,OAAO,CAMrE"}

package/dist/primitives/cube.d.ts

@@ -0,0 +1,21 @@
+import { Solid } from '../geometry/solid';
+import type { Vec3 as Vec3Type } from '../math/vec3';
+/** Options controlling how a `cube` is positioned relative to the origin. */
+export interface CubeOptions {
+    /**
+     * When `true`, the cube is centered on the origin. When `false`
+     * (default), one corner sits at the origin and the cube extends in
+     * `+x`, `+y`, `+z`.
+     */
+    readonly center?: boolean;
+}
+/**
+ * Creates an axis-aligned box `Solid`, matching OpenSCAD's `cube()`.
+ *
+ * `size` may be a single number (equal width/depth/height on all three
+ * axes) or a `Vec3` giving independent width (x), depth (y), and height
+ * (z). By default one corner sits at the origin; pass `{ center: true }`
+ * to center the box on the origin instead.
+ */
+export declare function cube(size: number | Vec3Type, options?: CubeOptions): Solid;
+//# sourceMappingURL=cube.d.ts.map

package/dist/primitives/cube.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cube.d.ts","sourceRoot":"","sources":["../../src/primitives/cube.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG1C,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,cAAc,CAAC;AAErD,6EAA6E;AAC7E,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,KAAK,CAgE1E"}

package/dist/primitives/cylinder.d.ts

@@ -0,0 +1,32 @@
+import { Solid } from '../geometry/solid';
+/** Options accepted by {@link cylinder}. */
+export interface CylinderOptions {
+    /** Radius of both ends. Overridden by `r1`/`r2` when either is given. */
+    readonly r?: number;
+    /** Bottom (z = 0, or z = -h/2 when centered) radius. Defaults to `r`. */
+    readonly r1?: number;
+    /** Top (z = h, or z = h/2 when centered) radius. Defaults to `r`. */
+    readonly r2?: number;
+    /**
+     * When `true`, the cylinder is centered on the z-axis (`z` from `-h/2` to
+     * `h/2`); otherwise it spans `z` from `0` to `h`. Defaults to `false`.
+     */
+    readonly center?: boolean;
+    /** Number of segments around the circumference. Defaults to `32`. */
+    readonly fn?: number;
+}
+/**
+ * Creates a cylinder (or, with unequal radii, a cone/frustum) solid
+ * centered on the z-axis, matching OpenSCAD's `cylinder()` semantics.
+ *
+ * Side faces are always emitted as triangles (2 per segment, or 1 at a
+ * degenerate zero-radius end) so every `Polygon` stays exactly planar even
+ * when tapered; top/bottom caps are single flat n-gons.
+ *
+ * @param h - Height along the z-axis. Must be `> 0`.
+ * @param options - Radius, taper, centering, and tessellation options.
+ * @throws {Error} If `h <= 0`, either radius is negative, both radii are
+ *   zero, or `fn < 3`.
+ */
+export declare function cylinder(h: number, options?: CylinderOptions): Solid;
+//# sourceMappingURL=cylinder.d.ts.map

package/dist/primitives/cylinder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cylinder.d.ts","sourceRoot":"","sources":["../../src/primitives/cylinder.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,4CAA4C;AAC5C,MAAM,WAAW,eAAe;IAC9B,yEAAyE;IACzE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAsBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,KAAK,CA+DxE"}

package/dist/primitives/polyhedron.d.ts

@@ -0,0 +1,36 @@
+import { Solid } from '../geometry/solid';
+import type { Vec3 } from '../math/vec3';
+/**
+ * Builds an arbitrary-mesh `Solid` from a flat list of points and a list of
+ * faces, each face being a list of indices into `points`. This is the raw
+ * escape hatch for geometry that has no dedicated primitive, mirroring
+ * OpenSCAD's `polyhedron()`.
+ *
+ * **Winding convention — read this if porting `.scad` data**: OpenSCAD's own
+ * `polyhedron()` conventionally expects each face's indices listed
+ * *clockwise* when viewed from outside (a well-known historical OpenSCAD
+ * quirk). This library instead uses *counter-clockwise from outside*
+ * consistently everywhere, matching `Plane.fromPoints`'s right-hand-rule
+ * convention used by every other primitive. So **this function expects each
+ * face's indices ordered counter-clockwise when viewed from outside** — the
+ * opposite of raw OpenSCAD `.scad` polyhedron() code. Porting OpenSCAD data
+ * as-is will silently produce inside-out geometry (inward-facing normals);
+ * reverse each face's index order first.
+ *
+ * Each face is trusted to be planar and convex, same as the standard
+ * OpenSCAD polyhedron contract — this function does not validate or repair
+ * non-planar/non-convex face data. It does validate structure: every face
+ * must have at least 3 indices, and every index must be in bounds for
+ * `points`.
+ *
+ * All vertices within a face share that face's flat-shading normal, derived
+ * from the face's own first three listed points via `Plane.fromPoints`.
+ *
+ * @param points - Flat list of point positions referenced by `faces`.
+ * @param faces - List of faces; each face is a list of indices into
+ *   `points`, ordered counter-clockwise when viewed from outside.
+ * @throws {Error} If any face has fewer than 3 indices, or if any index is
+ *   negative or `>= points.length`.
+ */
+export declare function polyhedron(points: readonly Vec3[], faces: readonly (readonly number[])[]): Solid;
+//# sourceMappingURL=polyhedron.d.ts.map

package/dist/primitives/polyhedron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyhedron.d.ts","sourceRoot":"","sources":["../../src/primitives/polyhedron.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,SAAS,IAAI,EAAE,EACvB,KAAK,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GACpC,KAAK,CA0BP"}

package/dist/primitives/sphere.d.ts

@@ -0,0 +1,35 @@
+import { Solid } from '../geometry/solid';
+/** Options accepted by {@link sphere}. */
+export interface SphereOptions {
+    /**
+     * Controls tessellation density, mirroring OpenSCAD's `$fn`. Used
+     * directly as the number of longitude segments (segments running around
+     * the sphere, pole to pole to pole). The number of latitude rings
+     * (bands stacked from the north pole to the south pole) is derived as
+     * `fn / 2`, floored, with a minimum of 2 — matching the common
+     * approximation that a sphere's silhouette should have roughly as many
+     * horizontal bands as it does vertical wedges around the equator.
+     * Defaults to `32`.
+     */
+    fn?: number;
+}
+/**
+ * Builds a UV-sphere of radius `r`, centered at the origin.
+ *
+ * Every face is a triangle. A UV-sphere's "band" faces between two
+ * latitude rings are natural quads, but four points on a sphere's curved
+ * surface are only ever approximately coplanar — this codebase's
+ * `Polygon` is required to be *exactly* planar, so each band quad is
+ * split into 2 triangles (always exactly planar) instead of being kept
+ * as a quad. The polar caps are triangle fans connecting the pole point
+ * to the nearest latitude ring, which are triangles already.
+ *
+ * Vertex normals are the exact smooth-shading normals for a sphere
+ * centered at the origin: each vertex's own position, normalized.
+ *
+ * @param r - Sphere radius.
+ * @param options - See {@link SphereOptions}.
+ * @throws {Error} If `options.fn` is less than 3.
+ */
+export declare function sphere(r: number, options?: SphereOptions): Solid;
+//# sourceMappingURL=sphere.d.ts.map

package/dist/primitives/sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere.d.ts","sourceRoot":"","sources":["../../src/primitives/sphere.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAK1C,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;OASG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,KAAK,CAuEhE"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@richardmcquiston01/more-open-scad",
+  "version": "0.2.0",
+  "description": "Framework agnostic TypeScript based package for generating STL files using commands similar to OpenSCAD.",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Richard McQuiston",
+    "email": "richard.mcquiston01@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RichardMcQuiston01/more-open-scad.git"
+  },
+  "homepage": "https://github.com/RichardMcQuiston01/more-open-scad#readme",
+  "bugs": {
+    "url": "https://github.com/RichardMcQuiston01/more-open-scad/issues"
+  },
+  "keywords": [
+    "openscad",
+    "stl",
+    "3d",
+    "csg",
+    "typescript"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:file": "eslint",
+    "format": "prettier --write .",
+    "test": "bun test",
+    "test:file": "bun test",
+    "build:js": "bun build src/index.ts --outdir dist --target browser --format esm",
+    "build:types": "tsc --project tsconfig.build.json --emitDeclarationOnly",
+    "build": "bun run build:js && bun run build:types",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/bun": "^1.1.14",
+    "eslint": "^9.17.0",
+    "prettier": "3.9.6",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.1"
+  }
+}