The best way to control Claude Code, Codex and more from any computer or phone

main
tsx 194 lines 6.5 KB
Raw
1 import { interpolate } from "remotion";
2 import type { ArchStep } from "../../shared/intro.ts";
3 import { hand, mono, sans } from "../fonts.ts";
4 import { brand } from "../theme.ts";
5 import { Arrow, drawProgress } from "./draw.tsx";
6
7 const clamp = { extrapolateLeft: "clamp", extrapolateRight: "clamp" } as const;
8 const W = 270;
9 const H = 124;
10
11 /**
12 * An architecture drawing: boxes appear one after another in the order
13 * given, and each arrow draws itself once both of its ends are on screen.
14 */
15 export const ArchView = ({ step, local }: { step: ArchStep; local: number }) => {
16 const byId = new Map(step.nodes.map((n) => [n.id, n]));
17 const order = (id: string) => step.nodes.findIndex((n) => n.id === id);
18 const appear = (id: string) =>
19 interpolate(local, [order(id) * 5, order(id) * 5 + 8], [0, 1], clamp);
20 const width = (id: string) => byId.get(id)?.w ?? W;
21 const height = (id: string) => byId.get(id)?.h ?? H;
22
23 /** Where a line from `a` towards `b` leaves `a`'s box. A tall box is entered level with the other end. */
24 const port = (a: string, b: string) => {
25 const p = byId.get(a)!;
26 const q = byId.get(b)!;
27 const dx = q.x - p.x;
28 const dy = q.y - p.y;
29 const h = height(a);
30 if (Math.abs(dx) * h > Math.abs(dy) * width(a) || h > H) {
31 const y = h > H ? Math.min(p.y + h / 2 - 24, Math.max(p.y - h / 2 + 24, q.y)) : p.y;
32 return { x: p.x + Math.sign(dx) * (width(a) / 2 + 10), y };
33 }
34 return { x: p.x, y: p.y + Math.sign(dy) * (h / 2 + 10) };
35 };
36
37 return (
38 <svg width={1920} height={1080} style={{ position: "absolute", left: 0, top: 0 }}>
39 {(step.lanes ?? []).map((lane, i) => (
40 <g key={lane.label} opacity={interpolate(local, [i * 4, i * 4 + 8], [0, 1], clamp)}>
41 <text
42 x={110}
43 y={lane.y + 14}
44 fontFamily={hand}
45 fontWeight={700}
46 fontSize={42}
47 fill={lane.color}
48 >
49 {lane.label}
50 </text>
51 </g>
52 ))}
53 {step.edges.map((edge) => {
54 const start = Math.max(order(edge.from), order(edge.to)) * 5 + 6;
55 const a = port(edge.from, edge.to);
56 const b = port(edge.to, edge.from);
57 const color = edge.dashed ? "#56b6c2" : brand.fgMuted;
58 const p = drawProgress(local, start, 10);
59 const mx = (a.x + b.x) / 2;
60 const my = (a.y + b.y) / 2;
61 if (edge.elbow) {
62 const p0 = byId.get(edge.from)!;
63 const q0 = byId.get(edge.to)!;
64 const sx = p0.x + Math.sign(q0.x - p0.x) * (width(edge.from) / 2 + 10);
65 const ty = q0.y + Math.sign(p0.y - q0.y) * (height(edge.to) / 2 + 10);
66 const d = `M ${sx} ${p0.y} L ${q0.x} ${p0.y} L ${q0.x} ${ty}`;
67 const dir = Math.sign(ty - p0.y);
68 return (
69 <g key={`${edge.from}-${edge.to}`}>
70 <path
71 d={d}
72 fill="none"
73 stroke={color}
74 strokeWidth={3}
75 strokeDasharray={3000}
76 strokeDashoffset={3000 * (1 - p)}
77 strokeLinejoin="round"
78 />
79 <path
80 d={`M ${q0.x - 11} ${ty - dir * 16} L ${q0.x} ${ty} L ${q0.x + 11} ${ty - dir * 16}`}
81 fill="none"
82 stroke={color}
83 strokeWidth={3}
84 opacity={p >= 1 ? 1 : 0}
85 />
86 {edge.label ? (
87 <text
88 x={q0.x - 18}
89 y={(p0.y + ty) / 2 + 8}
90 textAnchor="end"
91 fontFamily={mono}
92 fontSize={24}
93 fill="#7ee787"
94 opacity={interpolate(local, [start + 6, start + 12], [0, 1], clamp)}
95 >
96 {edge.label}
97 </text>
98 ) : null}
99 </g>
100 );
101 }
102 return (
103 <g key={`${edge.from}-${edge.to}`}>
104 {edge.dashed ? (
105 <path
106 d={`M ${a.x} ${a.y} L ${a.x + (b.x - a.x) * p} ${a.y + (b.y - a.y) * p}`}
107 stroke={color}
108 strokeWidth={3}
109 strokeDasharray="10 9"
110 opacity={0.8}
111 />
112 ) : (
113 <Arrow x1={a.x} y1={a.y} x2={b.x} y2={b.y} color={color} progress={p} bend={0} />
114 )}
115 {edge.label ? (
116 // Above a horizontal arrow, beside a vertical one: never on the line.
117 <g opacity={interpolate(local, [start + 6, start + 12], [0, 1], clamp)}>
118 <text
119 x={
120 Math.abs(b.x - a.x) > Math.abs(b.y - a.y)
121 ? mx
122 : b.x < a.x - 20
123 ? mx - 18
124 : mx + 18
125 }
126 y={Math.abs(b.x - a.x) > Math.abs(b.y - a.y) ? my - 18 : my + 8}
127 textAnchor={
128 Math.abs(b.x - a.x) > Math.abs(b.y - a.y)
129 ? "middle"
130 : b.x < a.x - 20
131 ? "end"
132 : "start"
133 }
134 fontFamily={mono}
135 fontSize={24}
136 fill={edge.dashed ? color : "#7ee787"}
137 >
138 {edge.label}
139 </text>
140 </g>
141 ) : null}
142 </g>
143 );
144 })}
145
146 {step.nodes.map((node) => {
147 const q = appear(node.id);
148 const w = width(node.id);
149 const h = height(node.id);
150 return (
151 <g
152 key={node.id}
153 opacity={q}
154 transform={`translate(${node.x} ${node.y}) scale(${0.92 + 0.08 * q})`}
155 >
156 <rect
157 x={-w / 2}
158 y={-h / 2}
159 width={w}
160 height={h}
161 rx={20}
162 fill={brand.bgElevated}
163 stroke={node.color}
164 strokeWidth={3.5}
165 />
166 <text
167 x={0}
168 y={node.sub ? -6 : 12}
169 textAnchor="middle"
170 fontFamily={sans}
171 fontWeight={700}
172 fontSize={36}
173 fill={brand.fg}
174 >
175 {node.title}
176 </text>
177 {node.sub ? (
178 <text
179 x={0}
180 y={34}
181 textAnchor="middle"
182 fontFamily={mono}
183 fontSize={22}
184 fill={brand.fgMuted}
185 >
186 {node.sub}
187 </text>
188 ) : null}
189 </g>
190 );
191 })}
192 </svg>
193 );
194 };