@octane-xplat/smooth-corners 0.14.0 → 0.15.0

package/dist/web/packages/smooth-corners/src/path.js

@@ -1,453 +0,0 @@
-import { a as st, i as ft, p as ot } from "../../../node_modules/.pnpm/@lisse_core@0.7.2/node_modules/@lisse/core/dist/chunk-BL6ZAFLB.js";
-//#region src/path.ts
-/** Shared smooth-corner path generation — pure TS, no DOM. Emits one
-*  `PathCommand[]` (absolute coords, arcs already center-parameterized) that
-*  web stringifies to `d`, iOS feeds `CGPathAdd*`, Android feeds
-*  `android.graphics.Path`, and macOS feeds `NSBezierPath`.
-*
-*  Lisse curves (`squircle`/`superellipse`/`clothoid`/`arc`) delegate to
-*  `@lisse/core/path`; `continuous` is our own builder — the Rosenfeld
-*  `UIBezierPath` constants reproducing Apple's fixed continuous corner
-*  (~0.25 px from SwiftUI `.continuous`; Lisse issue #103 /
-*  tools/apple-continuous-export). */
-function resolveOne(c) {
-	const cfg = typeof c === "number" ? { radius: c } : c ?? { radius: 0 };
-	return {
-		radius: cfg.radius,
-		curve: cfg.curve ?? "continuous",
-		smoothing: cfg.smoothing ?? .65,
-		exponent: cfg.exponent ?? 4,
-		preserveSmoothing: cfg.preserveSmoothing ?? true
-	};
-}
-function resolveOptions(options) {
-	if (typeof options === "number") {
-		const c = resolveOne(options);
-		return {
-			topLeft: c,
-			topRight: c,
-			bottomRight: c,
-			bottomLeft: c
-		};
-	}
-	if ("radius" in options) {
-		const c = resolveOne(options);
-		return {
-			topLeft: c,
-			topRight: c,
-			bottomRight: c,
-			bottomLeft: c
-		};
-	}
-	const p = options;
-	return {
-		topLeft: resolveOne(p.topLeft),
-		topRight: resolveOne(p.topRight),
-		bottomRight: resolveOne(p.bottomRight),
-		bottomLeft: resolveOne(p.bottomLeft)
-	};
-}
-/** Shoulder extent along each adjacent edge, as a multiple of R. */
-var CONT_P = 1.528665;
-var CONT_CURVE = [
-	[1.08849296, 0],
-	[.86840694, 0],
-	[.63149379, .07491139],
-	[.37282383, .16905956],
-	[.16905956, .37282383],
-	[.07491139, .63149379],
-	[0, .86840694],
-	[0, 1.08849296],
-	[0, 1.52866498]
-];
-var CONT_CURVE_YX = CONT_CURVE.map(([x, y]) => [y, x]);
-/** Absolute `C` commands for one continuous corner. `p` returned separately —
-*  the tangent distance from the vertex along the incoming edge. */
-function continuousCorner(w, h, radius, budget, orient) {
-	const r = Math.min(radius, budget / CONT_P);
-	const p = CONT_P * r;
-	if (r <= 0) return {
-		p: 0,
-		cmds: []
-	};
-	let fx;
-	let fy;
-	let seq = CONT_CURVE;
-	switch (orient) {
-		case "TR":
-			fx = (x, _y) => w - x * r;
-			fy = (_x, y) => y * r;
-			break;
-		case "BR":
-			fx = (x, _y) => w - x * r;
-			fy = (_x, y) => h - y * r;
-			seq = CONT_CURVE_YX;
-			break;
-		case "BL":
-			fx = (x, _y) => x * r;
-			fy = (_x, y) => h - y * r;
-			break;
-		case "TL":
-			fx = (x, _y) => x * r;
-			fy = (_x, y) => 0 + y * r;
-			seq = CONT_CURVE_YX;
-	}
-	const cmds = [];
-	for (let i = 0; i < seq.length; i += 3) {
-		const [c1, c2, e] = [
-			seq[i],
-			seq[i + 1],
-			seq[i + 2]
-		];
-		cmds.push({
-			c: "C",
-			x1: fx(c1[0], c1[1]),
-			y1: fy(c1[0], c1[1]),
-			x2: fx(c2[0], c2[1]),
-			y2: fy(c2[0], c2[1]),
-			x: fx(e[0], e[1]),
-			y: fy(e[0], e[1])
-		});
-	}
-	return {
-		p,
-		cmds
-	};
-}
-/** Parse a curve builder's per-orient relative segment starting at `pen`.
-*  Returns absolute commands. Lisse segments only emit `c`/`a`/`l`. */
-function segmentCommands(seg, pen) {
-	return parsePath(seg, pen.x, pen.y).filter((c) => c.c !== "M");
-}
-var TOKEN = /[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
-var ARITY = {
-	M: 2,
-	L: 2,
-	H: 1,
-	V: 1,
-	C: 6,
-	S: 4,
-	Q: 4,
-	T: 2,
-	A: 7,
-	Z: 0
-};
-/** Endpoint→center for a circular SVG arc (φ=0 — every Lisse emitter).
-*  Non-circular or rotated arcs throw: unsupported is loud, not silent. */
-function arcToCenter(x0, y0, rx, ry, rot, largeArc, sweep, x1, y1) {
-	if (x0 === x1 && y0 === y1) return null;
-	if (rx <= 0 || ry <= 0) return null;
-	if (rx !== ry || rot !== 0) throw new Error(`smooth-corners: only circular unrotated arcs are supported (got a ${rx} ${ry} ${rot})`);
-	const dx = (x0 - x1) / 2;
-	const dy = (y0 - y1) / 2;
-	const d2 = dx * dx + dy * dy;
-	let r = rx;
-	const lambda = d2 / (r * r);
-	if (lambda > 1) r *= Math.sqrt(lambda);
-	const h = Math.sqrt(Math.max(0, (r * r - d2) / d2));
-	const sign = largeArc !== sweep ? 1 : -1;
-	const cx = (x0 + x1) / 2 + sign * h * dy;
-	const cy = (y0 + y1) / 2 - sign * h * dx;
-	const deg = (v) => v * 180 / Math.PI;
-	const start = deg(Math.atan2(y0 - cy, x0 - cx));
-	let sweepDeg = deg(Math.atan2(y1 - cy, x1 - cx)) - start;
-	if (sweep && sweepDeg <= 0) sweepDeg += 360;
-	if (!sweep && sweepDeg >= 0) sweepDeg -= 360;
-	return {
-		c: "A",
-		cx,
-		cy,
-		r,
-		startDeg: start,
-		sweepDeg,
-		x: x1,
-		y: y1
-	};
-}
-/** Parse an SVG `d` string (or relative corner segment) into absolute
-*  `PathCommand[]`. Supports M L H V C S Q T A Z; `pen` seeds relative
-*  commands when parsing a mid-path segment. */
-function parsePath(d, penX = 0, penY = 0) {
-	const tokens = d.match(TOKEN) ?? [];
-	const out = [];
-	let i = 0;
-	let cmd = "";
-	let px = penX;
-	let py = penY;
-	let sx = penX;
-	let sy = penY;
-	const num = () => {
-		const t = tokens[i++];
-		const n = Number(t);
-		if (!Number.isFinite(n)) throw new Error(`smooth-corners: bad path token '${t}' in '${d}'`);
-		return n;
-	};
-	while (i < tokens.length) {
-		const t = tokens[i];
-		if (/[a-zA-Z]/.test(t)) {
-			cmd = t;
-			i++;
-			if (cmd === "Z" || cmd === "z") {
-				out.push({ c: "Z" });
-				px = sx;
-				py = sy;
-				continue;
-			}
-		}
-		if (!cmd) throw new Error(`smooth-corners: path data missing command: '${d}'`);
-		const rel = cmd === cmd.toLowerCase();
-		const upper = cmd.toUpperCase();
-		if (ARITY[upper] === void 0) throw new Error(`smooth-corners: unsupported path command '${cmd}'`);
-		if (upper === "S" || upper === "Q" || upper === "T") throw new Error(`smooth-corners: '${upper}' commands are not supported`);
-		switch (upper) {
-			case "M": {
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "M",
-					x,
-					y
-				});
-				px = sx = x;
-				py = sy = y;
-				cmd = rel ? "l" : "L";
-				break;
-			}
-			case "L": {
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "L",
-					x,
-					y
-				});
-				px = x;
-				py = y;
-				break;
-			}
-			case "H": {
-				const x = num() + (rel ? px : 0);
-				out.push({
-					c: "L",
-					x,
-					y: py
-				});
-				px = x;
-				break;
-			}
-			case "V": {
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "L",
-					x: px,
-					y
-				});
-				py = y;
-				break;
-			}
-			case "C": {
-				const x1 = num() + (rel ? px : 0);
-				const y1 = num() + (rel ? py : 0);
-				const x2 = num() + (rel ? px : 0);
-				const y2 = num() + (rel ? py : 0);
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				out.push({
-					c: "C",
-					x1,
-					y1,
-					x2,
-					y2,
-					x,
-					y
-				});
-				px = x;
-				py = y;
-				break;
-			}
-			case "A": {
-				const rx = num();
-				const ry = num();
-				const rot = num();
-				const fa = num();
-				const fs = num();
-				const x = num() + (rel ? px : 0);
-				const y = num() + (rel ? py : 0);
-				const arc = arcToCenter(px, py, rx, ry, rot, fa, fs, x, y);
-				if (arc) out.push(arc);
-				else out.push({
-					c: "L",
-					x,
-					y
-				});
-				px = x;
-				py = y;
-				break;
-			}
-		}
-	}
-	return out;
-}
-function lisseCornerSeg(corner, radius, budget, orient, pen) {
-	const out = ft(corner.curve)({
-		cornerRadius: radius,
-		smoothing: corner.smoothing,
-		exponent: corner.exponent,
-		preserveSmoothing: corner.preserveSmoothing,
-		roundingAndSmoothingBudget: budget
-	});
-	return {
-		p: out.p,
-		cmds: segmentCommands(out.pathSegment(orient), pen)
-	};
-}
-function cornerCmds(corner, normalized, orient, pen, w, h) {
-	if (corner.curve === "continuous") return continuousCorner(w, h, normalized.radius, normalized.roundingAndSmoothingBudget, orient);
-	return lisseCornerSeg(corner, normalized.radius, normalized.roundingAndSmoothingBudget, orient, pen);
-}
-var RECT = [
-	{
-		c: "M",
-		x: 0,
-		y: 0
-	},
-	{
-		c: "L",
-		x: 0,
-		y: 0
-	},
-	{
-		c: "L",
-		x: 0,
-		y: 0
-	},
-	{
-		c: "L",
-		x: 0,
-		y: 0
-	},
-	{ c: "Z" }
-];
-/** Absolute command list for the smooth-cornered rect. When no corner uses
-*  `continuous`, delegates to `@lisse/core` `generatePath` (keeping its
-*  capsule/blend fast paths) and parses the result; otherwise stitches
-*  per-corner segments itself (per-corner mixing with `continuous`). */
-function generateCommands(width, height, options) {
-	if (width <= 0 || height <= 0) return RECT;
-	const corners = resolveOptions(options);
-	if (!(corners.topLeft.curve === "continuous" || corners.topRight.curve === "continuous" || corners.bottomRight.curve === "continuous" || corners.bottomLeft.curve === "continuous")) return parsePath(ot(width, height, lisseOptions(corners)));
-	const normalized = st({
-		topLeftCornerRadius: corners.topLeft.radius,
-		topRightCornerRadius: corners.topRight.radius,
-		bottomRightCornerRadius: corners.bottomRight.radius,
-		bottomLeftCornerRadius: corners.bottomLeft.radius,
-		width,
-		height
-	});
-	const emit = (corner, n, orient, entryX, entryY) => cornerCmds(corner, n, orient, {
-		x: entryX,
-		y: entryY
-	}, width, height);
-	const pTL = previewP(corners.topLeft, normalized.topLeft, "TL", width, height);
-	const pTR = previewP(corners.topRight, normalized.topRight, "TR", width, height);
-	const pBR = previewP(corners.bottomRight, normalized.bottomRight, "BR", width, height);
-	const pBL = previewP(corners.bottomLeft, normalized.bottomLeft, "BL", width, height);
-	const out = [{
-		c: "M",
-		x: pTL,
-		y: 0
-	}];
-	out.push({
-		c: "L",
-		x: width - pTR,
-		y: 0
-	});
-	const tr = emit(corners.topRight, normalized.topRight, "TR", width - pTR, 0);
-	out.push(...tr.cmds);
-	out.push({
-		c: "L",
-		x: width,
-		y: height - pBR
-	});
-	const br = emit(corners.bottomRight, normalized.bottomRight, "BR", width, height - pBR);
-	out.push(...br.cmds);
-	out.push({
-		c: "L",
-		x: pBL,
-		y: height
-	});
-	const bl = emit(corners.bottomLeft, normalized.bottomLeft, "BL", pBL, height);
-	out.push(...bl.cmds);
-	out.push({
-		c: "L",
-		x: 0,
-		y: pTL
-	});
-	const tl = emit(corners.topLeft, normalized.topLeft, "TL", 0, pTL);
-	out.push(...tl.cmds);
-	out.push({ c: "Z" });
-	return out;
-}
-/** A corner's tangent distance without emitting commands (cheap for
-*  continuous; re-runs the lisse builder for other curves — called once per
-*  frame per corner, acceptable). */
-function previewP(corner, n, orient, w, h) {
-	return cornerCmds(corner, n, orient, {
-		x: 0,
-		y: 0
-	}, w, h).p;
-}
-function lisseOptions(corners) {
-	const { topLeft: a, topRight: b, bottomRight: c, bottomLeft: d } = corners;
-	if (a.radius === b.radius && a.radius === c.radius && a.radius === d.radius && a.curve === b.curve && a.curve === c.curve && a.curve === d.curve && a.smoothing === b.smoothing && a.smoothing === c.smoothing && a.smoothing === d.smoothing && a.exponent === b.exponent && a.exponent === c.exponent && a.exponent === d.exponent && a.preserveSmoothing === b.preserveSmoothing && a.preserveSmoothing === c.preserveSmoothing && a.preserveSmoothing === d.preserveSmoothing) return {
-		radius: a.radius,
-		curve: a.curve,
-		smoothing: a.smoothing,
-		exponent: a.exponent,
-		preserveSmoothing: a.preserveSmoothing
-	};
-	const per = (c) => ({
-		radius: c.radius,
-		curve: c.curve,
-		smoothing: c.smoothing,
-		exponent: c.exponent,
-		preserveSmoothing: c.preserveSmoothing
-	});
-	return {
-		topLeft: per(a),
-		topRight: per(b),
-		bottomRight: per(c),
-		bottomLeft: per(d)
-	};
-}
-var f = (n) => Math.round(n * 1e4) / 1e4;
-/** Serialize commands back to an SVG `d` (web `clip-path`, debug/tests). */
-function commandsToD(cmds) {
-	const parts = [];
-	for (const c of cmds) switch (c.c) {
-		case "M":
-			parts.push(`M ${f(c.x)} ${f(c.y)}`);
-			break;
-		case "L":
-			parts.push(`L ${f(c.x)} ${f(c.y)}`);
-			break;
-		case "C":
-			parts.push(`C ${f(c.x1)} ${f(c.y1)} ${f(c.x2)} ${f(c.y2)} ${f(c.x)} ${f(c.y)}`);
-			break;
-		case "A":
-			parts.push(`A ${f(c.r)} ${f(c.r)} 0 ${Math.abs(c.sweepDeg) > 180 ? 1 : 0} ${c.sweepDeg >= 0 ? 1 : 0} ${f(c.x)} ${f(c.y)}`);
-			break;
-		case "Z": parts.push("Z");
-	}
-	return parts.join(" ");
-}
-/** `d` for the smooth-cornered rect — Lisse's own string when no
-*  `continuous` corner is involved (byte-identical to upstream, incl.
-*  capsule/blend fast paths), our serialization otherwise. */
-function smoothPathD(width, height, options) {
-	const corners = resolveOptions(options);
-	if (!(corners.topLeft.curve === "continuous" || corners.topRight.curve === "continuous" || corners.bottomRight.curve === "continuous" || corners.bottomLeft.curve === "continuous") && width > 0 && height > 0) return ot(width, height, lisseOptions(corners));
-	return commandsToD(generateCommands(width, height, options));
-}
-//#endregion
-export { commandsToD, generateCommands, parsePath, smoothPathD };