/** @jsxRuntime automatic */ /** @jsxImportSource @alchemy.run/sigil */ /** * The yantra logo, rasterized at runtime. Geometry mirrors * website/src/brand/yantra.ts (the brand's source of truth): a downward * equilateral triangle inscribed in a circle, bindu at the center. The * shapes are signed distance functions in the brand's 24-unit viewBox, * sampled at the on-screen positions of a braille dot grid (2x4 dots per * cell), so stroke weight scales with the logo exactly as the SVG does. */ import { useMemo } from "@alchemy.run/sigil/react"; import type { JSX } from "react"; import { theme } from "../../../Util/Theme.ts"; import { Box, Text } from "../ui/index.ts"; const VIEWBOX = 24; const CENTER = 12; const CIRCLE_R = 9.5; const BINDU_R = 1.3; const STROKE_W = 1.5; // Strokes scale with the logo, but are snapped to whole braille dots so every // line renders at an even weight, and floored so small logos never break up. const MIN_STROKE_DOTS = 2; // Supersamples per braille dot along each axis; a dot is raised when at least // half of its cell is covered. const SAMPLES = 4; const COVERAGE_THRESHOLD = 0.5; // Terminals space braille dots evenly within a cell, but leave extra leading // between cells: a cell is 2 dot pitches wide and ~4.25 tall (3 pitches between // its 4 rows, plus a 1.25-pitch gap to the next cell). Sampling at those real // positions keeps circles round on screen instead of ~6% tall and lumpy at // every cell seam. const CELL_W_PITCHES = 2; const CELL_H_PITCHES = 4.25; type Point = readonly [number, number]; /** * Where each braille dot actually lands, in viewBox units, addressed by global * dot column `i` (0..cols*2) and dot row `j` (0..rows*4). The logo is centered * on the grid's midpoint, which is always a point of symmetry (a cell center or * the middle of an inter-cell gap), so symmetric shapes rasterize * symmetrically. */ interface DotGrid { cols: number; rows: number; /** viewBox units per dot pitch */ scale: number; dot: (i: number, j: number) => Point; } const makeGrid = (cols: number): DotGrid => { const width = cols * CELL_W_PITCHES; // logo width in dot pitches const rows = Math.ceil(width / CELL_H_PITCHES); const scale = VIEWBOX / width; const offsetY = (rows * CELL_H_PITCHES - width) / 2; const padY = (CELL_H_PITCHES - 4) / 2; return { cols, rows, scale, dot: (i, j) => [ (Math.floor(i / 2) * CELL_W_PITCHES + (i % 2) + 0.5) * scale, (Math.floor(j / 4) * CELL_H_PITCHES + padY + (j % 4) + 0.5 - offsetY) * scale, ], }; }; /** Per-dot coverage in [0, 1] for one shape on one grid. */ type Coverage = (i: number, j: number) => number; /** A shape that knows how to rasterize itself onto a dot grid. */ interface Shape { color: string; compile: (grid: DotGrid) => Coverage; } /** * Supersample a signed distance field over each dot's footprint (one pitch * square). Best for thin diagonal strokes. */ const areaSampled = (sd: (x: number, y: number) => number) => (grid: DotGrid): Coverage => { const step = grid.scale / SAMPLES; return (i, j) => { const [x, y] = grid.dot(i, j); const x0 = x - grid.scale / 2; const y0 = y - grid.scale / 2; let hits = 0; for (let b = 0; b < SAMPLES; b++) { for (let a = 0; a < SAMPLES; a++) { if (sd(x0 + (a + 0.5) * step, y0 + (b + 0.5) * step) <= 0) hits++; } } return hits / (SAMPLES * SAMPLES); }; }; const sdSegment = (px: number, py: number, [ax, ay]: Point, [bx, by]: Point) => { const abx = bx - ax; const aby = by - ay; const apx = px - ax; const apy = py - ay; const t = Math.max(0, Math.min(1, (apx * abx + apy * aby) / (abx * abx + aby * aby))); return Math.hypot(apx - t * abx, apy - t * aby); }; /** * Pull `inner` (per-line innermost dot index, measured outward from the * center) toward the center until it moves at most one dot between adjacent * lines. Each change only thickens the stroke, and the fixpoint is * order-independent, so symmetry is preserved. */ const smoothInnerEdge = (inner: Array) => { for (let changed = true; changed;) { changed = false; for (let k = 0; k < inner.length; k++) { const q = inner[k]; if (q === undefined) continue; for (const n of [inner[k - 1], inner[k + 1]]) { if (n !== undefined && q > n + 1) { inner[k] = n + 1; changed = true; } } } } }; /** * Stroked circle outline. Rasterizing the annulus directly (by area or by dot * center) rounds the outer and inner edges independently, so where their * stair-steps fall out of phase the stroke flickers a dot thicker and thinner * line to line. Instead, only the outer edge is snapped to the grid and the * stroke is filled inward from it by a whole-dot count derived from the true * thickness across that row (on the sides) or column (on the caps); that count * changes monotonically around the circle. The inner edge is then smoothed so * it never jumps two dots where the outer edge and the count step together. */ const ring = (cx: number, cy: number, r: number, strokeW: number, color: string): Shape => ({ color, compile: (grid) => { const W = grid.cols * 2; const H = grid.rows * 4; const ro = r + strokeW / 2; const ri = r - strokeW / 2; const at = (i: number, j: number): Point => { const [x, y] = grid.dot(i, j); return [x - cx, y - cy]; }; /** Outer edge and whole-dot stroke count across a chord at `offset`. */ const chord = (offset: number) => { const outer = Math.sqrt(ro * ro - offset * offset); const inner = Math.abs(offset) < ri ? Math.sqrt(ri * ri - offset * offset) : 0; return { outer, count: Math.max(1, Math.round((outer - inner) / grid.scale)) }; }; const on = Array.from({ length: H }, () => new Uint8Array(W)); // sides (|x| >= |y|): per dot row, dots are indexed n = 0, 1, … outward // from the vertical center line const rowEdge: Array = []; const rowInner: Array = []; for (let j = 0; j < H; j++) { const [, y] = at(0, j); if (Math.abs(y) >= ro) continue; const { outer, count } = chord(y); rowEdge[j] = Math.floor(outer / grid.scale - 0.5); rowInner[j] = rowEdge[j]! - count + 1; } // only rows whose inner edge is still on the side (past 45° the caps own // it) take part in smoothing, or the caps' short chords would drag it in const sideInner = rowInner.map((q, j) => q !== undefined && (q + 0.5) * grid.scale >= Math.abs(at(0, j)[1]) ? q : undefined, ); smoothInnerEdge(sideInner); sideInner.forEach((q, j) => q !== undefined && (rowInner[j] = q)); for (let j = 0; j < H; j++) { const edge = rowEdge[j]; if (edge === undefined) continue; const [, y] = at(0, j); for (let i = 0; i < W; i++) { const [x] = at(i, j); if (Math.abs(x) < Math.abs(y)) continue; const n = Math.round(Math.abs(x) / grid.scale - 0.5); if (n <= edge && n >= rowInner[j]!) on[j][i] = 1; } } // caps (|y| > |x|): per dot column, dots are indexed k = 0, 1, … inward // from the top. Rows are unevenly spaced (cell gaps), so walk the actual // dots; the bottom cap mirrors the top since the grid is symmetric. const colEdge: Array = []; const colInner: Array = []; for (let i = 0; i < W; i++) { const [x] = at(i, 0); if (Math.abs(x) >= ro) continue; const { outer, count } = chord(x); let top = 0; while (top < H / 2 && Math.abs(at(i, top)[1]) > outer) top++; colEdge[i] = top; colInner[i] = top + count - 1; } // smooth in "distance from center" terms, where inner edges move outward const half = H / 2; const fromCenter = colInner.map((k) => (k === undefined ? undefined : half - 1 - k)); const capInner = fromCenter.map((q, i) => q !== undefined && Math.abs(at(i, half - 1 - q)[1]) > Math.abs(at(i, 0)[0]) ? q : undefined, ); smoothInnerEdge(capInner); capInner.forEach((q, i) => q !== undefined && (fromCenter[i] = q)); for (let i = 0; i < W; i++) { const top = colEdge[i]; if (top === undefined) continue; const innerK = half - 1 - fromCenter[i]!; const [x] = at(i, 0); for (let k = top; k <= innerK && k < half; k++) { for (const j of [k, H - 1 - k]) { if (Math.abs(at(i, j)[1]) > Math.abs(x)) on[j][i] = 1; } } } return (i, j) => on[j][i]; }, }); /** Stroked closed polygon with round joins (stroke-linejoin="round"). */ const polygon = (pts: ReadonlyArray, strokeW: number, color: string): Shape => ({ color, compile: areaSampled((x, y) => { let d = Infinity; for (let k = 0; k < pts.length; k++) { d = Math.min(d, sdSegment(x, y, pts[k], pts[(k + 1) % pts.length])); } return d - strokeW / 2; }), }); /** * Filled circle, sampled at dot centers (area sampling leaves bumps on solid * fills). Some radii leave a narrow nub on the cap row or column, so the radius * is nudged by up to half a dot pitch to the closest one whose caps are at * least 40% of the widest span on both axes. */ const disc = (cx: number, cy: number, r: number, color: string): Shape => ({ color, compile: (grid) => { const W = grid.cols * 2; const H = grid.rows * 4; const inside = (radius: number) => (i: number, j: number) => { const [x, y] = grid.dot(i, j); return Math.hypot(x - cx, y - cy) <= radius; }; const capsOk = (radius: number) => { const test = inside(radius); const rowW = new Map(); const colH = new Map(); for (let j = 0; j < H; j++) { for (let i = 0; i < W; i++) { if (!test(i, j)) continue; rowW.set(j, (rowW.get(j) ?? 0) + 1); colH.set(i, (colH.get(i) ?? 0) + 1); } } const capRatio = (spans: Map) => { if (spans.size === 0) return 0; const keys = [...spans.keys()].sort((a, b) => a - b); const widest = Math.max(...spans.values()); return Math.min(spans.get(keys[0])!, spans.get(keys[keys.length - 1])!) / widest; }; return capRatio(rowW) >= 0.4 && capRatio(colH) >= 0.4; }; const step = grid.scale * 0.05; let radius = r; for (let k = 0; k <= 9; k++) { if (capsOk(r - k * step)) { radius = r - k * step; break; } if (capsOk(r + k * step)) { radius = r + k * step; break; } } const test = inside(radius); return (i, j) => (test(i, j) ? 1 : 0); }, }); /** * The yantra, mirroring yantra.ts: the triangle's circumradius is pulled in by * a quarter stroke so its tips merge into the ring. */ const yantra = (strokeW: number): Shape[] => { const triR = CIRCLE_R - strokeW / 4; const dx = triR * Math.cos(Math.PI / 6); const topY = CENTER - triR * Math.sin(Math.PI / 6); return [ ring(CENTER, CENTER, CIRCLE_R, strokeW, theme.color.accent), polygon( [ [CENTER, CENTER + triR], [CENTER - dx, topY], [CENTER + dx, topY], ], strokeW, theme.color.accent, ), disc(CENTER, CENTER, BINDU_R, theme.color.brand), ]; }; // braille dot bit per (row 0-3, column 0-1) subpixel const BRAILLE_BITS = [ [0x01, 0x08], [0x02, 0x10], [0x04, 0x20], [0x40, 0x80], ] as const; interface LogoRun { text: string; color?: string; } const rasterizeLogo = (cols: number): LogoRun[][] => { const grid = makeGrid(cols); const strokeW = Math.max(MIN_STROKE_DOTS, Math.round(STROKE_W / grid.scale)) * grid.scale; const layers = yantra(strokeW).map((shape) => ({ color: shape.color, coverage: shape.compile(grid), })); const lines: LogoRun[][] = []; for (let r = 0; r < grid.rows; r++) { const runs: LogoRun[] = []; const push = (text: string, color?: string) => { const last = runs[runs.length - 1]; if (last && last.color === color) last.text += text; else runs.push({ text, color }); }; for (let c = 0; c < cols; c++) { let bits = 0; // the cell's color is whichever shape covers the most of its raised dots const weight = new Map(); for (let sy = 0; sy < 4; sy++) { for (let sx = 0; sx < 2; sx++) { let union = 0; for (const layer of layers) { const cov = layer.coverage(c * 2 + sx, r * 4 + sy); if (cov === 0) continue; union = Math.max(union, cov); weight.set(layer.color, (weight.get(layer.color) ?? 0) + cov); } if (union >= COVERAGE_THRESHOLD) bits |= BRAILLE_BITS[sy][sx]; } } if (bits === 0) push(" "); else { let color: string | undefined; let best = 0; for (const [k, w] of weight) if (w > best) [color, best] = [k, w]; push(String.fromCharCode(0x2800 + bits), color); } } // drop trailing whitespace runs while (runs.length > 0) { const last = runs[runs.length - 1]; if (last.color !== undefined || last.text.trim() !== "") break; runs.pop(); } lines.push(runs); } while (lines.length > 0 && lines[0].length === 0) lines.shift(); while (lines.length > 0 && lines[lines.length - 1].length === 0) lines.pop(); return lines; }; // Braille rasterization is mojibake on non-Unicode terminals — the help // formatter skips mounting the logo entirely when Unicode is unavailable. type LogoProps = { cols: number }; export function Logo({ cols }: LogoProps): JSX.Element | null { const lines = useMemo(() => rasterizeLogo(cols), [cols]); return ( {lines.map((runs, i) => ( {runs.length === 0 ? " " : runs.map((run, j) => ( {run.text} ))} ))} ); }