Thread dimensions and modeled threads

/** The basic profile's diameters: { d (major), d1 (minor), d2 (pitch), p, depth }. */
export function threadDims(form, size) {
  const row = THREAD_TABLES[form]?.[size];
  if (!row) return null;
  const [d, p] = row;
  const depth = form === 'tr' ? p / 2 : 5 * Math.sqrt(3) / 16 * p;   // tr: H1 = P/2 · iso: 5H/8 with H = √3/2 · P
  return { d, p, d1: d - 2 * depth, d2: form === 'tr' ? d - p / 2 : d - 0.649519 * p, depth };
}

/**
 * The size that fits a round face of diameter `dia`: a shaft wants its major diameter (external), a bore its minor
 * diameter (the tap drill: ≥ D1, below the pitch diameter). → the size key, or null when none is within 12 %.
 */
export function sizeFor(form, dia, external) {
  let best = null, bd = Infinity;
  for (const size of Object.keys(THREAD_TABLES[form] || {})) {
    const g = threadDims(form, size);
    const want = external ? g.d : (g.d1 + g.d2) / 2;   // a bore: between the minor and pitch diameters
    const dd = Math.abs(dia - want);
    if (dd < bd) { bd = dd; best = size; }
  }
  return best !== null && bd <= 0.12 * dia ? best : null;
}

/**
 * The profile over one pitch as (u, r) corners, u ∈ [0, P] along the axis, r the radius; crest first. `shift` moves it
 * radially (− for a shaft's clearance, + for a bore's).
 */
export function profileCorners(form, size, shift = 0) {
  const g = threadDims(form, size);
  if (!g) return null;
  const R = g.d / 2 + shift, r = g.d1 / 2 + shift, p = g.p;
  // iso: crest P/8, flank 5P/16, root P/4, flank 5P/16 · tr: crest 0.366P, flank, root 0.366P, flank (flank = P/2·tan 15°)
  const crest = form === 'tr' ? p * (0.5 - Math.tan(Math.PI / 12) / 2) : p / 8;
  const root = form === 'tr' ? crest : p / 4;
  const flank = (p - crest - root) / 2;
  return [[0, R], [crest, R], [crest + flank, r], [crest + flank + root, r], [p, R]];
}

/** The profile's radius at u (any real number; periodic in P). */
export function profileAt(corners, u) {
  const p = corners[corners.length - 1][0];
  const w = ((u % p) + p) % p;
  for (let k = 1; k < corners.length; k++) {
    const [u0, r0] = corners[k - 1], [u1, r1] = corners[k];
    if (w <= u1 + 1e-15) return u1 - u0 < 1e-15 ? r1 : r0 + (r1 - r0) * (w - u0) / (u1 - u0);
  }
  return corners[0][1];
}

/**
 * The thread's cross-section square to the axis at z = 0 as one CCW polygon [[x, y]…]: r(θ) = profile(u) with
 * u = −P·θ/2π (right hand; left: +P·θ/2π), every profile corner a vertex, else steps of at most 360/segments degrees.
 */
export function boltSection(corners, { hand = 'right', segments = 96 } = {}) {
  const p = corners[corners.length - 1][0];
  const s = hand === 'left' ? 1 : -1;
  const th = new Set([0, 2 * Math.PI]);
  for (const [u] of corners) th.add((((s * u / p) % 1 + 1) % 1) * 2 * Math.PI);   // θ where u hits a corner
  const n = Math.max(24, segments);
  for (let k = 1; k < n; k++) th.add(2 * Math.PI * k / n);
  const list = [...th].sort((a, b) => a - b).filter((a, i, all) => i === 0 || a - all[i - 1] > 1e-9);
  if (2 * Math.PI - list[list.length - 1] < 1e-9) list.pop();
  return list.map((a) => { const r = profileAt(corners, s * p * a / (2 * Math.PI)); return [r * Math.cos(a), r * Math.sin(a)]; });
}

/**
 * The helical solid (a bolt's shape) from z = 0 to z = h along +z, twisted 360° per pitch; the screw motion keeps the
 * profile phase at z = 0. M = manifold-3d, T = its arena. → a Manifold.
 */
export function boltSolid(M, T, corners, h, { hand = 'right', segments = 96 } = {}) {
  const p = corners[corners.length - 1][0];
  const poly = boltSection(corners, { hand: 'right', segments });
  const cs = T(new M.CrossSection([poly], 'Positive'));
  const turns = h / p;
  const slices = Math.max(1, Math.ceil(turns * Math.max(24, segments)));
  const right = T(cs.extrude(h, slices - 1, 360 * turns));
  // a left-hand thread is the mirror image of a right-hand one (y → −y): manifold triangulates a negative twist's side
  // quads across their fold, ~1e-3 of the volume, so it is never extruded that way
  return hand === 'left' ? T(right.mirror([0, 1, 0])) : right;
}

/**
 * A thread's cutting tool in its own frame (axis +z, the thread from z = 0 to z = len): a bore's = the bolt's shape
 * (outward by `clearance`), a shaft's = a tube of radius `outer` less the bolt's shape (inward by `clearance`).
 * ext0 / ext1: how far it carries on past z = 0 / z = len (past an open end, so the cut is clean). → Manifold
 */
export function threadTool(M, T, { form, size, external, len, clearance = 0, hand = 'right', segments = 96, outer = 0, ext0 = 0, ext1 = 0, face = null }) {
  const corners = profileCorners(form, size, external ? -clearance : clearance);
  if (!corners) return null;
  // face { r, segments }: the faceted round face the thread is cut into. A shaft's crest (a bore's root) lying on those
  // facets would leave hundreds of slivers of them, so it moves just inside the facets (a hair, at most their sag)
  if (face) {
    const lo = face.r * Math.cos(Math.PI / Math.max(8, face.segments)), eps = 1e-4 * face.r;
    const k = external ? 0 : 2;   // the corner pair on the face: crest (0, 1) or root (2, 3)
    const v = corners[k][1];
    if (v > lo - eps && v < face.r + eps) {
      const to = external ? lo - eps : face.r + eps;
      for (const c of corners) if (Math.abs(c[1] - v) < 1e-12) c[1] = to;
    }
  }
  const h = len + ext0 + ext1;
  // start the bolt one pitch early so the phase at z = 0 stays the same whatever ext0 is (a whole number of turns)
  const p = corners[corners.length - 1][0];
  const pre = Math.ceil(ext0 / p) * p;
  const bolt = T(T(boltSolid(M, T, corners, len + pre + ext1, { hand, segments })).translate([0, 0, -pre]));
  if (!external) return pre > ext0 + 1e-9 ? T(bolt.trimByPlane([0, 0, 1], -ext0)) : bolt;
  const tube = T(T(T(M.CrossSection.circle(outer, Math.max(24, segments))).extrude(h)).translate([0, 0, -ext0]));
  const cut = T(tube.subtract(bolt));
  return cut;
}

const fmt = (v) => String(+Number(v).toFixed(3));