@code3d/screws 0.0.1-alpha.4 → 0.0.1-alpha.7

package/src/library/iso-7379.ts

@@ -0,0 +1,230 @@
+import {
+  cylinder,
+  frustum,
+  union,
+  type Bound,
+  type CanonicalElements,
+  type LineAnchor,
+  type SolidModel,
+} from '@code3d/core';
+import {
+  metric,
+  atY,
+  externalThread,
+  hexSocket,
+  positive,
+  validateHead,
+  withCounterbore,
+  type HeadSpecification,
+  type MetricSize,
+  type ClearanceHole,
+  type ClearanceHoleOptions as CommonClearanceHoleOptions,
+  type CounterboredHole,
+  type CounterboreOptions,
+} from './common.js';
+export type {
+  ClearanceHole,
+  HoleElements,
+  CounterboredHole,
+  CounterboredHoleElements,
+  CounterboreOptions,
+} from './common.js';
+
+export type Specification = HeadSpecification &
+  Readonly<{
+    shoulderDiameter: number;
+    shoulderBodyDiameter: number;
+    threadLength: number;
+    neckDiameter: number;
+    headReliefLength: number;
+    threadReliefLength: number;
+    hexSocketWidth: number;
+    hexSocketDepth: number;
+  }>;
+// ISO 7379:1983, plain heads, maximum h8 shoulder diameter and nominal b.
+// https://www.finesz.com/ISO7379.php
+function specification(
+  size: MetricSize,
+  shoulderDiameter: number,
+  shoulderBodyDiameter: number,
+  threadLength: number,
+  headDiameter: number,
+  headHeight: number,
+  neckDiameter: number,
+  threadReliefLength: number,
+  underHeadRadius: number,
+  hexSocketWidth: number,
+  hexSocketDepth: number,
+): Specification {
+  return {
+    ...metric(size),
+    shoulderDiameter,
+    shoulderBodyDiameter,
+    threadLength,
+    headDiameter,
+    headHeight,
+    neckDiameter,
+    headReliefLength: 2.5,
+    threadReliefLength,
+    underHeadRadius,
+    hexSocketWidth,
+    hexSocketDepth,
+  };
+}
+export const specifications = {
+  6.5: specification('M5', 6.5, 6.49, 9.5, 10, 4.5, 3.86, 2, 0.25, 3, 2.4),
+  8: specification('M6', 8, 7.99, 11, 13, 5.5, 4.58, 2.5, 0.4, 4, 3.3),
+  10: specification('M8', 10, 9.99, 13, 16, 7, 6.25, 3.1, 0.6, 5, 4.2),
+  13: specification('M10', 13, 12.98, 16, 18, 9, 7.91, 3.7, 0.6, 6, 4.9),
+  16: specification('M12', 16, 15.98, 18, 24, 11, 9.57, 4.4, 0.6, 8, 6.6),
+} as const;
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export type ScrewElements = CanonicalElements &
+  Readonly<{
+    headTop: Bound;
+    headBottom: Bound;
+    shoulderTop: Bound;
+    shoulderBottom: Bound;
+    shoulderAxis: LineAnchor;
+    threadTop: Bound;
+    threadBottom: Bound;
+    threadAxis: LineAnchor;
+  }>;
+export type Screw = SolidModel<ScrewElements>;
+export type ClearanceHoleOptions = Omit<CommonClearanceHoleOptions, 'fit'>;
+export type PlainHoleOptions = ClearanceHoleOptions &
+  Readonly<{counterbore?: false}>;
+export type CounterboredHoleOptions = ClearanceHoleOptions &
+  Readonly<{counterbore: true | CounterboreOptions}>;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'number' ? specifications[input] : input;
+}
+/**
+ * Length is the shoulder length L; the fixed threaded projection b is additional.
+ * @code3d.arguments [8, 20]
+ * @code3d.param shoulderLength {kind: 'length'}
+ */
+export function screw(input: ScrewInput, shoulderLength: number): Screw {
+  const spec = resolveSpecification(input);
+  validateHead(spec);
+  for (const key of [
+    'shoulderDiameter',
+    'shoulderBodyDiameter',
+    'threadLength',
+    'neckDiameter',
+    'headReliefLength',
+    'threadReliefLength',
+  ] as const)
+    positive(key, spec[key]);
+  positive('Shoulder length', shoulderLength);
+  if (shoulderLength <= spec.headReliefLength)
+    throw new Error('Shoulder length must exceed the head relief length.');
+  if (
+    spec.shoulderBodyDiameter <= spec.nominalDiameter ||
+    spec.shoulderBodyDiameter > spec.shoulderDiameter ||
+    spec.shoulderDiameter >= spec.headDiameter
+  )
+    throw new Error(
+      'Shoulder diameter must lie between thread and head diameters.',
+    );
+  if (
+    spec.neckDiameter >= spec.nominalDiameter ||
+    spec.threadLength - spec.threadReliefLength < spec.pitch
+  )
+    throw new Error(
+      'Thread relief must leave a reduced neck and at least one thread pitch.',
+    );
+  const chamfer = Math.min(0.3, spec.headHeight / 10);
+  const barrel = atY(
+    cylinder(spec.headDiameter / 2, spec.headHeight - chamfer),
+    (spec.headHeight - chamfer) / 2,
+  );
+  const crown = atY(
+    frustum(spec.headDiameter / 2, spec.headDiameter / 2 - chamfer, chamfer),
+    spec.headHeight - chamfer / 2,
+  );
+  const head = hexSocket(
+    union([barrel, crown]),
+    spec.hexSocketWidth,
+    spec.hexSocketDepth,
+    spec.headHeight,
+  );
+  const shoulderDatum = atY(
+    cylinder(spec.shoulderBodyDiameter / 2, shoulderLength),
+    -shoulderLength / 2,
+  );
+  const relief = atY(
+    cylinder(
+      spec.shoulderBodyDiameter / 2 - spec.underHeadRadius,
+      spec.headReliefLength,
+    ),
+    -spec.headReliefLength / 2,
+  );
+  const shoulder = atY(
+    cylinder(
+      spec.shoulderBodyDiameter / 2,
+      shoulderLength - spec.headReliefLength,
+    ),
+    -(shoulderLength + spec.headReliefLength) / 2,
+  );
+  const neck = atY(
+    cylinder(spec.neckDiameter / 2, spec.threadReliefLength + 0.05),
+    -shoulderLength - (spec.threadReliefLength + 0.05) / 2,
+  );
+  const thread = atY(
+    externalThread(spec, spec.threadLength - spec.threadReliefLength),
+    -shoulderLength - (spec.threadLength + spec.threadReliefLength) / 2,
+  );
+  return union([head, relief, shoulder, neck, thread]).expose({
+    headTop: head.up,
+    headBottom: head.down,
+    shoulderTop: shoulderDatum.up,
+    shoulderBottom: shoulderDatum.down,
+    shoulderAxis: shoulderDatum.axis,
+    threadTop: neck.up,
+    threadBottom: thread.down,
+    threadAxis: thread.axis,
+  });
+}
+/**
+ * Shoulder passage with 0.2 mm diametral clearance and an optional head recess.
+ * @code3d.arguments [8, 10]
+ */
+export function clearanceHole(input: ScrewInput, depth: number): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CounterboredHoleOptions,
+): CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  depth: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole {
+  const spec = resolveSpecification(input);
+  const options = typeof depth === 'number' ? {depth} : depth;
+  positive('Hole depth', options.depth);
+  const diameter = options.diameter ?? spec.shoulderDiameter + 0.2;
+  positive('Clearance diameter', diameter);
+  if (diameter <= spec.shoulderBodyDiameter)
+    throw new Error(
+      'Clearance diameter must exceed the shoulder body diameter.',
+    );
+  const shaft = cylinder(diameter / 2, options.depth);
+  return withCounterbore(
+    shaft.expose({
+      shaftTop: shaft.up,
+      shaftBottom: shaft.down,
+      shaftAxis: shaft.axis,
+    }),
+    spec,
+    options,
+  );
+}

package/src/library/iso-7380-1.ts

@@ -0,0 +1,110 @@
+import {
+  metric,
+  validateHead,
+  headedScrew,
+  hexSocket,
+  roundHead,
+  clearanceHole as buildClearanceHole,
+  type HeadSpecification,
+  type MetricSize,
+  type Screw,
+  type ClearanceHole,
+  type CounterboredHole,
+  type ClearanceHoleOptions,
+  type PlainHoleOptions,
+  type CounterboredHoleOptions,
+} from './common.js';
+export type {
+  ClearanceFit,
+  Screw,
+  ScrewElements,
+  ClearanceHole,
+  HoleElements,
+  CounterboredHole,
+  CounterboredHoleElements,
+  ClearanceHoleOptions,
+  PlainHoleOptions,
+  CounterboredHoleOptions,
+  CounterboreOptions,
+} from './common.js';
+
+export type Specification = HeadSpecification &
+  Readonly<{hexSocketWidth: number; hexSocketDepth: number}>;
+
+// ISO 7380-1, k/dk maxima and nominal drive dimensions; millimetres.
+// https://eshop-ro.boellhoff.com/out/media/pdf/ISO_7380-1_Stahl_10.9_Innensechskant___en.pdf
+function specification(
+  size: MetricSize,
+  headDiameter: number,
+  headHeight: number,
+  hexSocketWidth: number,
+  hexSocketDepth: number,
+  underHeadRadius: number,
+): Specification {
+  return {
+    ...metric(size),
+    headDiameter,
+    headHeight,
+    hexSocketWidth,
+    hexSocketDepth,
+    underHeadRadius,
+  };
+}
+export const specifications = {
+  M3: specification('M3', 5.7, 1.65, 2, 1.04, 0.1),
+  M4: specification('M4', 7.6, 2.2, 2.5, 1.3, 0.2),
+  M5: specification('M5', 9.5, 2.75, 3, 1.56, 0.2),
+  M6: specification('M6', 10.5, 3.3, 4, 2.08, 0.25),
+  M8: specification('M8', 14, 4.4, 5, 2.6, 0.4),
+  M10: specification('M10', 17.5, 5.5, 6, 3.12, 0.4),
+  M12: specification('M12', 21, 6.6, 8, 4.16, 0.6),
+} as const;
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+/** Nominal partial thread b; the builder limits it to the available shank. */
+export function threadLength(spec: Specification, _length: number): number {
+  return 2 * spec.nominalDiameter + 12;
+}
+/**
+ * @code3d.arguments ['M6', 18]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  validateHead(spec);
+  const blank = roundHead(
+    spec.headDiameter,
+    spec.headHeight,
+    Math.max(spec.nominalDiameter, spec.hexSocketWidth * 1.3),
+  );
+  return headedScrew(
+    hexSocket(blank, spec.hexSocketWidth, spec.hexSocketDepth, spec.headHeight),
+    spec,
+    length,
+    threadLength(spec, length),
+  );
+}
+
+/** @code3d.arguments ['M6', 10] */
+export function clearanceHole(input: ScrewInput, depth: number): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CounterboredHoleOptions,
+): CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole {
+  return buildClearanceHole(resolveSpecification(input), options);
+}

package/src/library/iso-7380-2.ts

@@ -0,0 +1,135 @@
+import {cylinder, union} from '@code3d/core';
+import {
+  metric,
+  validateHead,
+  positive,
+  atY,
+  headedScrew,
+  hexSocket,
+  roundHead,
+  clearanceHole as buildClearanceHole,
+  type HeadSpecification,
+  type MetricSize,
+  type Screw,
+  type ClearanceHole,
+  type CounterboredHole,
+  type ClearanceHoleOptions,
+  type PlainHoleOptions,
+  type CounterboredHoleOptions,
+} from './common.js';
+export type {
+  ClearanceFit,
+  Screw,
+  ScrewElements,
+  ClearanceHole,
+  HoleElements,
+  CounterboredHole,
+  CounterboredHoleElements,
+  ClearanceHoleOptions,
+  PlainHoleOptions,
+  CounterboredHoleOptions,
+  CounterboreOptions,
+} from './common.js';
+
+export type Specification = HeadSpecification &
+  Readonly<{
+    hexSocketWidth: number;
+    hexSocketDepth: number;
+    buttonDiameter: number;
+    collarHeight: number;
+  }>;
+
+// ISO 7380-2:2022, collar diameter dc, button diameter dk and total head height k.
+// https://www.iso.org/standard/78700.html
+// https://eshop-cz.boellhoff.com/out/media/pdf/ISO_7380-2_Edelstahl_A2_Innensechskant___en.pdf
+function specification(
+  size: MetricSize,
+  headDiameter: number,
+  buttonDiameter: number,
+  headHeight: number,
+  collarHeight: number,
+  hexSocketWidth: number,
+  hexSocketDepth: number,
+  underHeadRadius: number,
+): Specification {
+  return {
+    ...metric(size),
+    headDiameter,
+    buttonDiameter,
+    headHeight,
+    collarHeight,
+    hexSocketWidth,
+    hexSocketDepth,
+    underHeadRadius,
+  };
+}
+export const specifications = {
+  M3: specification('M3', 6.9, 5.2, 1.65, 0.7, 2, 1.04, 0.1),
+  M4: specification('M4', 9.4, 7.2, 2.2, 0.8, 2.5, 1.3, 0.2),
+  M5: specification('M5', 11.8, 8.8, 2.75, 1, 3, 1.56, 0.2),
+  M6: specification('M6', 13.6, 10, 3.3, 1.2, 4, 2.08, 0.25),
+  M8: specification('M8', 17.8, 13.2, 4.4, 1.5, 5, 2.6, 0.4),
+  M10: specification('M10', 21.9, 16.5, 5.5, 2, 6, 3.12, 0.4),
+  M12: specification('M12', 26, 19.4, 6.6, 2.4, 8, 4.16, 0.6),
+} as const;
+export type Size = keyof typeof specifications;
+export type ScrewInput = Size | Specification;
+export function resolveSpecification(input: ScrewInput): Specification {
+  return typeof input === 'string' ? specifications[input] : input;
+}
+/** Nominal partial thread b; the builder limits it to the available shank. */
+export function threadLength(spec: Specification, _length: number): number {
+  return 2 * spec.nominalDiameter + 12;
+}
+/**
+ * @code3d.arguments ['M6', 18]
+ * @code3d.param length {kind: 'length'}
+ */
+export function screw(input: ScrewInput, length: number): Screw {
+  const spec = resolveSpecification(input);
+  validateHead(spec);
+  positive('Collar height', spec.collarHeight);
+  positive('Button diameter', spec.buttonDiameter);
+  if (
+    spec.collarHeight >= spec.headHeight ||
+    spec.buttonDiameter >= spec.headDiameter
+  )
+    throw new Error('Button and collar must fit the head envelope.');
+  const collar = cylinder(spec.headDiameter / 2, spec.collarHeight);
+  const crown = atY(
+    roundHead(
+      spec.buttonDiameter,
+      spec.headHeight - spec.collarHeight,
+      Math.max(spec.nominalDiameter, spec.hexSocketWidth * 1.3),
+    ),
+    spec.headHeight / 2,
+  );
+  const blank = union([collar, crown]);
+  return headedScrew(
+    hexSocket(blank, spec.hexSocketWidth, spec.hexSocketDepth, spec.headHeight),
+    spec,
+    length,
+    threadLength(spec, length),
+  );
+}
+
+/** @code3d.arguments ['M6', 10] */
+export function clearanceHole(input: ScrewInput, depth: number): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: PlainHoleOptions,
+): ClearanceHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: CounterboredHoleOptions,
+): CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole;
+export function clearanceHole(
+  input: ScrewInput,
+  options: number | ClearanceHoleOptions,
+): ClearanceHole | CounterboredHole {
+  return buildClearanceHole(resolveSpecification(input), options);
+}

package/src/library/thread.ts

@@ -98,7 +98,13 @@ function makeHelicalThreadShape({
   const threaded = core.fuse(teeth);
   core.delete();
   teeth.delete();
-  return threaded.rotate(-90, [0, 0, 0], [1, 0, 0]).translate([0, -y / 2, 0]);
+  // The axial profile width extends past the fade's quarter-pitch centreline.
+  // Face both ends. Keep the tool clear of the crest to avoid tangent slivers.
+  const envelope = makeCylinder(majorRadius + pitch, y);
+  const trimmed = threaded.intersect(envelope);
+  threaded.delete();
+  envelope.delete();
+  return trimmed.rotate(-90, [0, 0, 0], [1, 0, 0]).translate([0, -y / 2, 0]);
 }
 
 function threadProfile(