Isometric line figures that answer the pointer. For React and for anything with a DOM.
/**
* The skill's kernel: packages/hairline/src/core as one plain script that
* defines a single global, HL. `node scripts/kernel.mjs` writes
* skills/hairline-create/kernel.js; with `--check` it writes nothing and exits
* 1 when the committed file is not what the source gives now.
*
* The output is not minified: an agent reads the index at its top, and a
* person can read the rest. Its first line carries the hash of everything
* after it, which is how the skill's validator knows a kernel was not edited.
*/
import { build } from "esbuild";
import { createHash } from "node:crypto";
import { readFileSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
const ROOT = fileURLToPath(new URL("..", import.meta.url));
const OUT = join(ROOT, "skills/hairline-create/kernel.js");
const FILES = ["iso", "motion", "stage", "styles"];
/* One name per line, three spaces in: test/skill/kernel.test.ts holds this list to HL's keys. */
const INDEX = `/*
* HL: everything a figure may call. Read this index; the code under it is the
* package's src/core, unchanged, and a figure should not need to read it.
*
* Every figure is drawn in a 400 × 320 viewBox. World space is x/y on the
* ground and z up. Plates are filled with the ground colour and painted back
* to front, so a nearer one covers a farther one: append in that order. At
* the default camera, Cam(45, 0.5, S), +x runs down to the right and +y down
* to the left, so the corner with the largest x and y is nearest the viewer:
* append by ascending x + y, from the far corner (smallest x and y) to it.
*
* Camera
* Cam(azDeg, k, S) a camera: azimuth in degrees, k = sin(elevation) (0.5 is the 2:1 view), S = scale
* fit(C, points, cx, cy) centres the box of [x, y, z] points on (cx, cy); call it once, before proj
* it only centres, it never scales: choose S by trying values, with the most extreme pose in points.
* The six figures use S 1.42 to 2.12; the boxes they fit come out 230 to 310 wide and 180 to 245 tall
* proj(C) returns P(x, y, z), which gives [sx, sy]
* unproj(C, sx, sy, z) the world [x, y] under a screen point, on the plane at height z
* facing(C) returns front(sample): whether a ring sample faces the camera
* Rounded solids
* rrect(u0, v0, u1, v1, r, n) a rounded rectangle, as a ring of samples {u, v, nu, nv}
* circ(R, n) a circle, as a ring
* rings(x0, y0, x1, y1, r, b) [ring, inner]: a rounded footprint and its crease ring, inset by b
* r, the corner radius, is cut to half the shorter side. b, the crease's inset in world units
* (0.6 to 2.2 in the figures), must stay under half the shorter side or the crease turns inside out
* prism(P, front, ring, inner, z0, z1) {sil, crease}: a solid standing from z0 to z1, as two path strings
* ringAt(P, ring, z) the ring's points, projected at height z
* run(ring, keep) the one cyclic run of samples that pass keep
* hull(points) the convex hull of screen points
* extremes(P, ring) [left, right, nearest] samples: where dashed drops fall from
* fillet(points, radii, n) rounds every vertex of a closed polygon; returns the new points
* radii is an array, one radius per vertex, each cut to half its shorter edge; a single number gives NaN.
* n is the steps round each corner, default 4: each vertex becomes n + 1 points
* ghost(P, front, ring, z0, depth) a reflection's path {d, y0, y1}; reflect() draws it for you
* Paths and numbers
* poly(points) a closed path string
* open(points) an open polyline string
* seg(a, b) one segment between two screen points [sx, sy], as its own subpath; project world points with P first
* clamp(v, a, b)
* lerp(a, b, t)
* rad(deg)
* r2(n) two decimals
* The continuous clock: one spring per moving number
* spring(x, opts) at rest on x; write .t to retarget; opts {k, c, m, eps}, default k 100, c 18, m 1
* stepS(sp, dt) advances by dt seconds; returns whether it is still moving
* The discrete clock: a 700ms tween on (.32, .72, 0, 1)
* tween(v, dur) at rest on v; dur defaults to 700 (ms)
* tset(tw, to, now, delay) retargets from where it is, after delay ms: the stagger
* the same target again does nothing, so calling it on every pointer move is safe
* tval(tw, now) its value at now
* tdone(tw, now) whether it has landed
* bezier(x1, y1, x2, y2) a CSS cubic-bezier, as a function of progress
* EASE_LIFT the lift curve itself
* reducedMotion() true when the reader asked for less motion; springs and tweens already land at once
* setReducedMotion(on) the loop's business, not a figure's
* Drawing
* mk(tag, attrs, parent) one svg element: the only way a figure makes a node
* solid(parent) {g, sil, cr}: a group holding a silhouette path and a crease path
* put(solid, paths) writes prism()'s {sil, crease} into solid()'s {sil, cr}: sil into sil, crease into cr
* flatDot(parent, C, r, cls) a dot lying on the ground plane; cls is "dot", "dot m" or "dot off"
* place(el, point) moves a dot or a circle to [sx, sy]
* reflect(svg, parent, P, front, ring, z0, depth) a fading mirror under a solid
* fade(svg, y0, y1, a0) a vertical fade, as a mask; returns the value for a mask attribute
* Life
* register(stage, tick) joins the one frame loop; tick(dt in seconds, now in ms) returns true to ask for another frame; gives {wake, unregister}
* pointer(stage, handlers) {move(point), down(point), leave()}, points in viewBox units; returns its disposer
* disposer() {add, on, dispose}: collects tear-down, so destroy is bag.dispose
* The bench's business, not a figure's
* css(lightDark)
* inject(root)
* tour(stage, stops, onStop) an unseen pointer that walks the stops, [x, y] in viewBox units or null to leave, and gives way to a real one; onStop(i) on each arrival; returns {stop}
* LAP the default stops: a diamond around the centre, then a leave
*
* Classes, on path, polygon, ellipse and line. They are the whole palette; a
* figure sets no colour, width or fill of its own.
* (none) filled with the ground colour, medium stroke
* sil the silhouette's stroke hi the bright stroke: the only highlight
* lo the dim stroke nf no fill fo fill only, no stroke
* dash a dashed guide
* dot a bright dot dot m a medium dot dot off a dim dot
*/`;
/** The kernel's text, from the source as it is now. */
export async function kernel() {
const result = await build({
stdin: {
contents: FILES.map((f) => `export * from "./${f}";`).join("\n"),
resolveDir: join(ROOT, "packages/hairline/src/core"),
sourcefile: "kernel.ts",
loader: "ts",
},
// esbuild names each source file in a comment, relative to this: the same on every machine
absWorkingDir: ROOT,
bundle: true,
format: "iife",
globalName: "HL",
target: "es2020",
charset: "utf8",
legalComments: "none",
write: false,
});
const body = `${INDEX}\n${result.outputFiles[0].text.trimEnd()}\n/* /hairline kernel */\n`;
return `/* hairline kernel sha256:${createHash("sha256").update(body).digest("hex")} */\n${body}`;
}
if (process.argv[1] === fileURLToPath(import.meta.url)) {
const text = await kernel();
if (process.argv.includes("--check")) {
let have = "";
try { have = readFileSync(OUT, "utf8"); } catch { /* not generated yet: stale */ }
if (have !== text) {
console.error("skills/hairline-create/kernel.js is stale: run `pnpm kernel` and commit the result.");
process.exit(1);
}
console.log("kernel is current");
} else {
writeFileSync(OUT, text);
console.log(`wrote skills/hairline-create/kernel.js: ${text.split("\n").length} lines, ${Buffer.byteLength(text)} bytes`);
}
}