@logomarks/core 0.1.11 → 0.2.0

package/src/forms/hooks.js

@@ -0,0 +1,204 @@
+/**
+ * Bold hooks: capsules whose round end runs on into a curl that wraps a neighbour's round end, the gap exact all round,
+ * and their Track build (the same layout drawn as two tracks). Angles are degrees, 0 right, 90 down. From the Logomarks
+ * tools (hookparts.mjs, batch 214, "Bold · Hooks", and its editions in batch 220).
+ */
+import { I, U, circle, fillet, pill, poly, rad, soften, stroke, tracks } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/**
+ * A hook: the end of a piece it grows from, the neighbour's cap centre it wraps, and how far it sweeps.
+ *
+ * @typedef {object} Hook
+ * @property {0 | 1} [end] The end it grows from: 0 the first point, 1 (the default) the last.
+ * @property {readonly number[]} c The neighbour's cap centre.
+ * @property {number} [rn] The neighbour's cap radius (HOOK_W / 2).
+ * @property {number} [sw] The sweep, degrees; or give `e`.
+ * @property {number} [e] The angle the curl should end at (the neighbour's end direction), when `sw` isn't given.
+ * @property {number} [past] Degrees past `e`.
+ * @property {number} [t0] The curl's width at its root (the piece's width).
+ * @property {number} [t1] Its width at the tip (0.44 of the piece's width).
+ */
+
+/** The capsule's width. */
+export const HOOK_W = 150;
+
+/**
+ * The point d from p at angle a.
+ *
+ * @param {readonly number[]} p The point.
+ * @param {number} a The angle, degrees.
+ * @param {number} d The distance.
+ * @returns {Point} The point reached.
+ */
+export const hookAt = (p, a, d) => [p[0] + d * Math.cos(rad(a)), p[1] + d * Math.sin(rad(a))];
+
+/**
+ * The angle from p to q, degrees.
+ *
+ * @param {readonly number[]} p From.
+ * @param {readonly number[]} q To.
+ * @returns {number} The angle.
+ */
+const ang = (p, q) => (Math.atan2(q[1] - p[1], q[0] - p[0]) * 180) / Math.PI;
+
+/**
+ * The distance from p to q.
+ *
+ * @param {readonly number[]} p From.
+ * @param {readonly number[]} q To.
+ * @returns {number} The distance.
+ */
+const dist = (p, q) => Math.hypot(q[0] - p[0], q[1] - p[1]);
+
+/**
+ * Where a piece's cap centre sits to hook the neighbour cap at c: at angle a from c, the two caps and the gap apart.
+ *
+ * @param {readonly number[]} c The neighbour's cap centre.
+ * @param {number} a The angle from it, degrees.
+ * @param {number} g The gap.
+ * @param {number} [r=HOOK_W / 2] This cap's radius.
+ * @param {number} [rn=HOOK_W / 2] The neighbour's.
+ * @returns {Point} The cap centre.
+ */
+export const kiss = (c, a, g, r = HOOK_W / 2, rn = HOOK_W / 2) => hookAt(c, a, r + rn + g);
+
+/**
+ * The curl: a band whose inner edge is radius ri about c, from angle a0 sweeping sw degrees, tapering t0 → t1, with a
+ * round tip.
+ *
+ * @param {readonly number[]} c The centre.
+ * @param {number} ri The inner radius.
+ * @param {number} a0 The start angle, degrees.
+ * @param {number} sw The sweep, degrees.
+ * @param {number} t0 The width at the start.
+ * @param {number} t1 The width at the tip.
+ * @param {number} [n=120] Steps along it.
+ * @returns {Shape} The curl.
+ */
+export const curl = (c, ri, a0, sw, t0, t1, n = 120) => {
+	const inner = [], outer = [];
+	for (let i = 0; i <= n; i++) { const f = i / n, a = a0 + sw * f, t = t1 + (t0 - t1) * (1 - f) ** 2; inner.push(hookAt(c, a, ri)); outer.push(hookAt(c, a, ri + t)); }
+	return U(poly([...inner, ...outer.reverse()]), circle(...hookAt(c, a0 + sw, ri + t1 / 2), t1 / 2, 120));
+};
+
+/**
+ * A piece: a capsule w wide along `pts` (corners filleted by `bend`), with hooks. Each hook names the end it grows from,
+ * the neighbour's cap centre and the sweep; it logs when the end isn't a kiss from the neighbour. The root of each curl is
+ * filleted (`soft`) where it leaves the round end, and only there, so a same-piece gap under 2·soft (a bowl's tip near its
+ * stem) doesn't close up; `whole` fillets every inner corner of a piece with no such gap.
+ *
+ * @param {readonly Point[]} pts The capsule's centreline.
+ * @param {readonly Hook[]} [hooks=[]] Its hooks.
+ * @param {{ w?: number, bend?: number, g?: number, soft?: number, whole?: boolean }} [o] Width (HOOK_W), corner fillet
+ *   (90), gap (22), root fillet (40), and whether to fillet every inner corner.
+ * @returns {Shape} The piece.
+ */
+export const piece = (pts, hooks = [], { w = HOOK_W, bend = 90, g = 22, soft = 40, whole = false } = {}) => {
+	const body = pts.length === 2 ? pill(pts[0], pts[1], w) : stroke(bend ? fillet(pts, bend) : pts, w, { roundCaps: true, chunk: 8 });
+	const curls = hooks.map(({ end = 1, c, rn = HOOK_W / 2, sw, e, past = 0, t0 = w, t1 = 0.44 * w }) => {
+		const q = end ? pts.at(-1) : pts[0];
+		const d = dist(c, q), want = w / 2 + rn + g; if (Math.abs(d - want) > 0.5) console.log(`  hook off by ${(d - want).toFixed(1)}`);
+		const a0 = ang(c, q); if (sw == null) { const dd = ((e - a0 + 540) % 360) - 180; sw = dd + Math.sign(dd) * past; }
+		return curl(c, rn + g, a0, sw, t0, t1);
+	});
+	const roots = hooks.map(({ end = 1 }) => circle(...(end ? pts.at(-1) : pts[0]), 0.9 * w, 160));
+	if (soft && whole) return soften(U(body, ...curls), soft, 0);
+	return soft && roots.length ? U(body, ...curls, I(soften(U(body, ...curls), soft, 0), ...(roots.length > 1 ? [U(...roots)] : roots))) : U(body, ...curls);
+};
+
+/**
+ * The Track band's width for the gap g: 74 at 22, so the Track build lands on the house Track rules once fitted. Pass it
+ * as `r` and `rn` to kiss() for a Track layout.
+ *
+ * @param {number} g The gap.
+ * @returns {number} The band width.
+ */
+export const TB = (g) => (74 * g) / 22;
+
+/**
+ * The Track build of a piece: its centreline run on round each hook's neighbour (at the kiss distance, so the curl's inner
+ * track clears the neighbour's tracks by g), drawn as two tracks 26 wide at pitch 48, both scaled with g.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @param {readonly Hook[]} [hooks=[]] Its hooks (`end`, `c`, `sw` or `e` and `past`).
+ * @param {{ g?: number, bend?: number }} [o] The gap (22) and the corner fillet (60).
+ * @returns {Shape} The two tracks.
+ */
+export const trackPiece = (pts, hooks = [], { g = 22, bend = 60 } = {}) => {
+	let path = pts.slice();
+	for (const { end = 1, c, sw: sw0, e, past = 0 } of hooks) {
+		if (!end) path = path.slice().reverse(); const q = path.at(-1), a0 = ang(c, q);
+		let sw = sw0; if (sw == null) { const dd = ((e - a0 + 540) % 360) - 180; sw = dd + Math.sign(dd) * past; }
+		path = [...path, ...arc(c, dist(c, q), a0, a0 + sw, Math.max(8, Math.ceil(Math.abs(sw) / 4))).slice(1)];
+	}
+	return tracks(bend ? fillet(path, bend) : path, { n: 2, pitch: (48 * g) / 22, w: (26 * g) / 22 });
+};
+
+/**
+ * Points along an arc about c, radius r, from a0 to a1 degrees.
+ *
+ * @param {readonly number[]} c The centre.
+ * @param {number} r The radius.
+ * @param {number} a0 The start angle.
+ * @param {number} a1 The end angle.
+ * @param {number} [n=60] Steps.
+ * @returns {Point[]} n + 1 points.
+ */
+export const arc = (c, r, a0, a1, n = 60) => [...Array(n + 1)].map((_, i) => hookAt(c, a0 + ((a1 - a0) * i) / n, r));
+
+/**
+ * A neighbour's end, for a hook: its cap centre and the way the end faces.
+ *
+ * @param {readonly Point[]} pts The neighbour's centreline.
+ * @param {0 | 1} [end=1] Which end.
+ * @returns {{ c: Point, e: number }} The cap centre and the angle the end faces.
+ */
+export const endOf = (pts, end = 1) => (end ? { c: pts.at(-1), e: ang(pts.at(-2), pts.at(-1)) } : { c: pts[0], e: ang(pts[1], pts[0]) });
+
+/**
+ * Every point of every ring of a shape.
+ *
+ * @param {Shape} s The shape.
+ * @returns {Point[]} The points.
+ */
+export const pts0 = (s) => s.flatMap((pg) => pg.flatMap((r) => r));
+
+/**
+ * The least distance between two shapes' outline points.
+ *
+ * @param {Shape} a One shape.
+ * @param {Shape} b The other.
+ * @returns {number} The distance.
+ */
+const near = (a, b) => { let m = 1e9; const pa = pts0(a), pb = pts0(b); for (const p of pa) for (const q of pb) { const d = (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2; if (d < m) m = d; } return Math.sqrt(m); };
+
+/** join()'s check: set `on` to have it log any two pieces closer than the gap. */
+export const hookCheck = { on: false };
+
+/**
+ * The pieces as one shape; with hookCheck.on, it logs any two that come closer than the gap.
+ *
+ * @param {number} g The gap.
+ * @param {...Shape} ps The pieces.
+ * @returns {Shape} Their union.
+ */
+export const join = (g, ...ps) => {
+	if (hookCheck.on) for (let i = 0; i < ps.length; i++) for (let j = i + 1; j < ps.length; j++) { const d = near(ps[i], ps[j]); if (d < g - 0.6) console.log(`  pieces ${i},${j} only ${d.toFixed(1)} apart (g ${g.toFixed(1)})`); }
+	return U(...ps);
+};
+
+/**
+ * For the Track build: a straight run must enter the curl on its tangent (a corner there kinks the outer track), so the
+ * piece's end sits a quarter turn round from where the bold build puts it: c + (TB(g) + g) along d ± 90°.
+ *
+ * @param {readonly number[]} c The neighbour's cap centre.
+ * @param {number} d The run's direction, degrees.
+ * @param {number} side Which side: 1 or −1.
+ * @param {number} g The gap.
+ * @returns {Point} The piece's end.
+ */
+export const tq = (c, d, side, g) => hookAt(c, d + side * 90, TB(g) + g);

package/src/forms/index.d.ts

@@ -0,0 +1,22 @@
+export * from './geo.js';
+export * from './discs.js';
+export * from './hooks.js';
+export * from './jog.js';
+export * from './tech.js';
+export * from './emblems.js';
+export * from './shatter.js';
+export * from './slats.js';
+export * from './flow.js';
+export * from './folds.js';
+export * from './swash.js';
+export * from './ref.js';
+export * from './tracks.js';
+export * from './lines.js';
+export type { Hook } from './hooks.js';
+export type { JogArm } from './jog.js';
+export type { Rail, Shard, ShardMove } from './shatter.js';
+export type { Slat, SlatRowOptions, SlatEdges } from './slats.js';
+export type { FlowOptions } from './flow.js';
+export type { SwashOptions } from './swash.js';
+export type { StripeEdge } from './ref.js';
+export type { TrackKit } from './tracks.js';

package/src/forms/index.js

@@ -0,0 +1,24 @@
+/**
+ * @module @logomarks/core/forms
+ *
+ * The constructions the Bold, Line and Track families are drawn with, on the 512 canvas with the house gap: needle
+ * gaps, knobs and split discs (geo), one disc cut so a moved piece keeps its gap (discs), capsules whose ends curl round
+ * a neighbour (hooks), jogged bursts and chamfer checkers (jog), sparkles, ribbons and keyed chevrons (tech), the split
+ * emblem's horizon and grounds (emblems), a form breaking into shards (shatter), turning slats, flow grids, fold seams
+ * and straps, swashes, rotation, stripes, guilloche and speed letters (ref), the Track editions' kit (tracks), and soft
+ * blobs, Rail lines, chamfered paths and interlocking overlaps (lines).
+ */
+export * from './geo.js';
+export * from './discs.js';
+export * from './hooks.js';
+export * from './jog.js';
+export * from './tech.js';
+export * from './emblems.js';
+export * from './shatter.js';
+export * from './slats.js';
+export * from './flow.js';
+export * from './folds.js';
+export * from './swash.js';
+export * from './ref.js';
+export * from './tracks.js';
+export * from './lines.js';

package/src/forms/jog.d.ts

@@ -0,0 +1,33 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** One jogged arm's options. */
+export interface JogArm {
+	r0?: number;
+	rb?: number;
+	breaks?: readonly number[];
+	R: number;
+	w: number;
+	g: number;
+	shift: number;
+	scarf?: number;
+	innerShift?: number;
+	cx?: number;
+	cy?: number;
+}
+
+/** The point `along` the axis at deg from (cx, cy), stepped `side` square to it. */
+export function axisAt(deg: number, along: number, side?: number, cx?: number, cy?: number): Point;
+/** A bar on the axis at deg from a0 to a1, w wide, `side` off the axis, its ends slanted by cut0 / cut1. */
+export function axisBar(deg: number, a0: number, a1: number, w: number, side?: number, o?: { cut0?: number; cut1?: number; cx?: number; cy?: number }): Polygon;
+/** One jogged arm: runs broken by g and stepped sideways. */
+export function jogArm(deg: number, o: JogArm): Shape;
+/** n jogged arms round the centre, the first at deg0. */
+export function jogBurst(n: number, deg0: number, o: JogArm, each?: (i: number) => Partial<JogArm>): Shape;
+/** A polygon with its corners cut at 45° by c (one or one per corner). */
+export function chamfer(pts: readonly Point[], c: number | readonly number[]): Polygon;
+/** A box from its corners, chamfered by c. */
+export function chamferBox(x0: number, y0: number, x1: number, y1: number, c?: number | readonly number[]): Polygon;
+/** A checker's dark cells, corner meetings cut so two squares are parted by exactly g. */
+export function checkerCells(x0: number, y0: number, p: number, cols: number, rows: number, g: number, o?: { parity?: 0 | 1; outer?: number; skip?: (i: number, j: number) => boolean }): Shape;
+/** Throws unless a stands at least g (less 0.5) clear of b. */
+export function assertClear(a: Geom, b: Geom, g: number, what?: string): void;

package/src/forms/jog.js

@@ -0,0 +1,162 @@
+/**
+ * Jog bursts and chamfer checkers. A jog burst is straight bars radiating from a centre, each broken part way along and
+ * its outer run stepped sideways, parallel to itself (a splice jog), so the burst looks mis-registered; the break is a gap
+ * g along the arm (square, or a scarf cut at an angle, measured square to the cut), so the two runs are parted by exactly
+ * the house gap wherever they face each other. A chamfer checker is a heavy slab with 45° chamfered corners and a small
+ * checker of chamfered squares tucked into a corner: two dark squares that meet corner to corner have that corner cut at
+ * 45° with legs of g/√2, so they are parted by exactly g and stay full size. Angles are degrees, y down. From the
+ * Logomarks tools (jogparts.mjs, batch 244, "Bold · Jog" and "Bold · Chamfer").
+ */
+import { C, U, I, poly, grow } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/**
+ * The point at distance `along` on the axis at angle `deg` from (cx, cy), stepped `side` square to it.
+ *
+ * @param {number} deg The axis's angle.
+ * @param {number} along The distance along it.
+ * @param {number} [side=0] The step square to it.
+ * @param {number} [cx=C] The axis's origin.
+ * @param {number} [cy=C] The axis's origin.
+ * @returns {Point} The point.
+ */
+export const axisAt = (deg, along, side = 0, cx = C, cy = C) => {
+	const a = (deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
+	return [cx + c * along - s * side, cy + s * along + c * side];
+};
+
+/**
+ * A bar on the axis at `deg` from `a0` to `a1` along it, `w` wide, centred `side` off the axis. `cut0` / `cut1` slant its
+ * ends: the end line turned that many degrees off square (positive leans the end forward on the +side).
+ *
+ * @param {number} deg The axis's angle.
+ * @param {number} a0 Where the bar starts along it.
+ * @param {number} a1 Where it ends.
+ * @param {number} w Its width.
+ * @param {number} [side=0] Its offset from the axis.
+ * @param {{ cut0?: number, cut1?: number, cx?: number, cy?: number }} [o] The end slants and the axis's origin.
+ * @returns {Polygon} The bar.
+ */
+export const axisBar = (deg, a0, a1, w, side = 0, { cut0 = 0, cut1 = 0, cx = C, cy = C } = {}) => {
+	const t0 = Math.tan((cut0 * Math.PI) / 180) * (w / 2), t1 = Math.tan((cut1 * Math.PI) / 180) * (w / 2);
+	const P = (al, sd) => axisAt(deg, al, sd, cx, cy);
+	return poly([P(a0 - t0, side - w / 2), P(a1 - t1, side - w / 2), P(a1 + t1, side + w / 2), P(a0 + t0, side + w / 2)]);
+};
+
+/**
+ * One arm of a jog burst.
+ *
+ * @typedef {object} JogArm
+ * @property {number} [r0] Where the inner run starts (0: the centre).
+ * @property {number} [rb] The break (or give `breaks`).
+ * @property {readonly number[]} [breaks] Several breaks, each run stepped `shift` further than the last.
+ * @property {number} R Where the outer run ends.
+ * @property {number} w The bar's width.
+ * @property {number} g The gap at each break.
+ * @property {number} shift Each run's step square to the axis (positive is clockwise on screen).
+ * @property {number} [scarf] The breaks' slant, degrees off square; the gap stays g square to the cut.
+ * @property {number} [innerShift] The inner run's own step.
+ * @property {number} [cx] The centre.
+ * @property {number} [cy] The centre.
+ */
+
+/**
+ * One jogged arm on the axis at `deg`: an inner run from `r0` to the break at `rb`, a gap g, and an outer run on to `R`
+ * stepped `shift` square to the axis. A slanted face stepped sideways slides along the axis by shift·tan, so each later
+ * run starts that much further on.
+ *
+ * @param {number} deg The axis's angle.
+ * @param {JogArm} o The arm.
+ * @returns {Shape} The arm.
+ */
+export const jogArm = (deg, { r0 = 0, rb, breaks = [rb], R, w, g, shift, scarf = 0, innerShift = 0, cx = C, cy = C }) => {
+	const a = (scarf * Math.PI) / 180, half = g / 2 / Math.cos(a), t = Math.tan(a); // the axial half-gap that leaves g square to a slanted cut
+	const runs = []; let from = r0, side = innerShift;
+	breaks.forEach((b, i) => { runs.push(axisBar(deg, from, b - half, w, side, { cut0: i ? scarf : 0, cut1: scarf, cx, cy })); side += shift; from = b + half + shift * t; });
+	runs.push(axisBar(deg, from, R, w, side, { cut0: scarf, cx, cy }));
+	return U(...runs);
+};
+
+/**
+ * n jogged arms round the centre, the first at `deg0`; `each(i)` may override any jogArm option per arm (a shift's sign, a
+ * break radius). The inner runs meet at the centre when r0 is 0.
+ *
+ * @param {number} n The number of arms.
+ * @param {number} deg0 The first arm's angle.
+ * @param {JogArm} o Every arm's options.
+ * @param {(i: number) => Partial<JogArm>} [each] Per-arm overrides.
+ * @returns {Shape} The burst.
+ */
+export const jogBurst = (n, deg0, o, each = () => ({})) => U(...[...Array(n)].map((_, i) => jogArm(deg0 + (i * 360) / n, { ...o, ...each(i) })));
+
+/**
+ * A polygon with each corner cut at 45° (along the line square to its bisector) by `c` along both edges: a number for
+ * every corner or one per corner, 0 keeping it sharp. Points run in any order; corners are cut symmetrically.
+ *
+ * @param {readonly Point[]} pts The corners.
+ * @param {number | readonly number[]} c The cut.
+ * @returns {Polygon} The chamfered polygon.
+ */
+export const chamfer = (pts, c) => {
+	const n = pts.length, cs = Array.isArray(c) ? c : pts.map(() => c), out = [];
+	for (let i = 0; i < n; i++) {
+		const p = pts[i], a = pts[(i - 1 + n) % n], b = pts[(i + 1) % n], k = cs[i];
+		if (!k) { out.push(p); continue; }
+		const ua = [(a[0] - p[0]) / Math.hypot(a[0] - p[0], a[1] - p[1]), (a[1] - p[1]) / Math.hypot(a[0] - p[0], a[1] - p[1])];
+		const ub = [(b[0] - p[0]) / Math.hypot(b[0] - p[0], b[1] - p[1]), (b[1] - p[1]) / Math.hypot(b[0] - p[0], b[1] - p[1])];
+		out.push([p[0] + ua[0] * k, p[1] + ua[1] * k], [p[0] + ub[0] * k, p[1] + ub[1] * k]);
+	}
+	return poly(out);
+};
+
+/**
+ * A box from its corners, its corners (top-left, top-right, bottom-right, bottom-left) chamfered by c.
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} x1 Right.
+ * @param {number} y1 Bottom.
+ * @param {number | readonly number[]} [c=0] The chamfer, for every corner or one per corner.
+ * @returns {Polygon} The box.
+ */
+export const chamferBox = (x0, y0, x1, y1, c = 0) => chamfer([[x0, y0], [x1, y0], [x1, y1], [x0, y1]], c);
+
+/**
+ * A checker of `cols` × `rows` cells of size p from (x0, y0): the dark cells (where (i + j) % 2 === parity, less any
+ * `skip(i, j)`) as full squares, each corner that meets another dark square cut at 45° with legs of g/√2, so two squares
+ * meeting corner to corner are parted by exactly g; `outer` chamfers every other corner too.
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} p The cell size.
+ * @param {number} cols Cells across.
+ * @param {number} rows Cells down.
+ * @param {number} g The gap.
+ * @param {{ parity?: 0 | 1, outer?: number, skip?: (i: number, j: number) => boolean }} [o] Which cells are dark, the
+ *   free corners' chamfer (0: sharp) and cells to leave out.
+ * @returns {Shape} The checker.
+ */
+export const checkerCells = (x0, y0, p, cols, rows, g, { parity = 0, outer = 0, skip = () => false } = {}) => {
+	const dark = (i, j) => i >= 0 && j >= 0 && i < cols && j < rows && (i + j) % 2 === parity && !skip(i, j), c = g / Math.SQRT2, out = [];
+	for (let j = 0; j < rows; j++) for (let i = 0; i < cols; i++) if (dark(i, j)) {
+		const cut = [[-1, -1], [1, -1], [1, 1], [-1, 1]].map(([di, dj]) => (dark(i + di, j + dj) ? c : outer));
+		out.push(chamferBox(x0 + i * p, y0 + j * p, x0 + (i + 1) * p, y0 + (j + 1) * p, cut));
+	}
+	return U(...out);
+};
+
+/**
+ * Throws unless every part of `a` stands at least g (less a half-unit tolerance) clear of `b`.
+ *
+ * @param {Geom} a One shape.
+ * @param {Geom} b The other.
+ * @param {number} g The gap.
+ * @param {string} [what='parts'] What to call them in the error.
+ * @returns {void}
+ * @throws {Error} When they come closer than the gap.
+ */
+export const assertClear = (a, b, g, what = 'parts') => { if (I(grow(a, g - 0.5), b).length) throw new Error(`${what} closer than the gap`); };

package/src/forms/lines.d.ts

@@ -0,0 +1,32 @@
+import type { Point, Polygon, Shape, Geom } from '../geometry/types.js';
+
+/** A blob: radius R wobbled by sine terms [k, amplitude, phase]; sy squashes it. */
+export function blob(cx: number, cy: number, R: number, terms?: readonly (readonly number[])[], sy?: number, n?: number): Polygon;
+/** The same blob grown by g all round. */
+export function blobGrown(cx: number, cy: number, R: number, terms: readonly (readonly number[])[], sy?: number, g?: number): Polygon;
+/** The Cairo pentagonal tiling on unit cells round the origin (t = 0.2257: every edge equal). */
+export function cairo(t?: number): Point[][];
+/** The polygons whose centres lie within r of (cx, cy). */
+export function near<T extends readonly (readonly number[])[]>(list: readonly T[], cx: number, cy: number, r: number): T[];
+/** A polyline with every inner corner cut at 45° by c (or one per inner corner). */
+export function chamPath(pts: readonly Point[], c: number | readonly number[]): Point[];
+/** A Rail: two tracks w wide, pitch apart, along an open polyline, corners mitred, ends flat. */
+export function railsOf(pts: readonly Point[], w?: number, pitch?: number): Shape;
+/** A closed Rail round a regular n-gon whose centre path has inradius r. */
+export function railRing(cx: number, cy: number, r: number, n: number, deg?: number, w?: number, pitch?: number): Shape;
+/** A closed Rail along any polygon, corners mitred. */
+export function railLoop(pts: readonly Point[], w?: number, pitch?: number): Shape;
+/** Points from a to b bowed sideways by k times the length at the middle. */
+export function bow(a: readonly number[], b: readonly number[], k: number, n?: number): Point[];
+/** A slot g wide leaving the canvas centre at angle a, from `from` to `to` along it. */
+export function slot(a: number, g: number, from?: number, to?: number): Polygon;
+/** The two half-planes either side of the line p→q: [left, right]. */
+export function halves(p: readonly number[], q: readonly number[]): Polygon[];
+/** Shapes in a chain along p→q, each in front of the next on the left and behind it on the right, gap g. */
+export function lockChain(list: readonly Geom[], p: readonly number[], q: readonly number[], g?: number): Shape;
+/** a and b overlapped: a in front left of p→q, b in front right of it. */
+export function lockAlong(a: Geom, b: Geom, p: readonly number[], q: readonly number[], g?: number): Shape;
+/** The least distance between two shapes' outline points. */
+export function gapBetween(a: Geom, b: Geom): number;
+/** A part slid along deg until it sits exactly g clear of `fixed`. */
+export function slideToGap(fixed: Geom, part: Geom, deg: number, g: number, far?: number): Geom;