@harmonics/lattice-ui 0.1.0 → 0.5.0

package/dist/hexes-DN9eyQho.js

@@ -0,0 +1,624 @@
+var e = {
+	width: 76.21,
+	height: 132,
+	half: 38.11
+}, t = {
+	sky: "M 76.21 66.00 L 38.11 88.00 L -0.00 66.00 L 0.00 22.00 L 38.11 0.00 L 76.21 22.00 Z M 38.11 132.00 L 0.00 154.00 L -38.11 132.00 L -38.11 88.00 L -0.00 66.00 L 38.11 88.00 Z M 114.32 132.00 L 76.21 154.00 L 38.11 132.00 L 38.11 88.00 L 76.21 66.00 L 114.32 88.00 Z",
+	earth: "M 76.21 66.00 L 38.11 88.00 L -0.00 66.00 L 0.00 22.00 L 38.11 0.00 L 76.21 22.00 Z M 38.11 44.00 L 76.21 66.00 M 57.16 55.00 L 57.16 77.00 L 38.11 66.00 Z M 38.11 44.00 L 38.11 88.00 M 38.11 66.00 L 19.05 77.00 L 19.05 55.00 Z M 38.11 44.00 L -0.00 66.00 M 19.05 55.00 L -0.00 44.00 L 19.05 33.00 Z M 38.11 44.00 L 0.00 22.00 M 19.05 33.00 L 19.05 11.00 L 38.11 22.00 Z M 38.11 44.00 L 38.11 0.00 M 38.11 22.00 L 57.16 11.00 L 57.16 33.00 Z M 38.11 44.00 L 76.21 22.00 M 57.16 33.00 L 76.21 44.00 L 57.16 55.00 Z M 38.11 132.00 L 0.00 154.00 L -38.11 132.00 L -38.11 88.00 L -0.00 66.00 L 38.11 88.00 Z M 0.00 110.00 L 38.11 132.00 M 19.05 121.00 L 19.05 143.00 L 0.00 132.00 Z M 0.00 110.00 L 0.00 154.00 M 0.00 132.00 L -19.05 143.00 L -19.05 121.00 Z M 0.00 110.00 L -38.11 132.00 M -19.05 121.00 L -38.11 110.00 L -19.05 99.00 Z M 0.00 110.00 L -38.11 88.00 M -19.05 99.00 L -19.05 77.00 L -0.00 88.00 Z M 0.00 110.00 L -0.00 66.00 M -0.00 88.00 L 19.05 77.00 L 19.05 99.00 Z M 0.00 110.00 L 38.11 88.00 M 19.05 99.00 L 38.11 110.00 L 19.05 121.00 Z M 114.32 132.00 L 76.21 154.00 L 38.11 132.00 L 38.11 88.00 L 76.21 66.00 L 114.32 88.00 Z M 76.21 110.00 L 114.32 132.00 M 95.26 121.00 L 95.26 143.00 L 76.21 132.00 Z M 76.21 110.00 L 76.21 154.00 M 76.21 132.00 L 57.16 143.00 L 57.16 121.00 Z M 76.21 110.00 L 38.11 132.00 M 57.16 121.00 L 38.11 110.00 L 57.16 99.00 Z M 76.21 110.00 L 38.11 88.00 M 57.16 99.00 L 57.16 77.00 L 76.21 88.00 Z M 76.21 110.00 L 76.21 66.00 M 76.21 88.00 L 95.26 77.00 L 95.26 99.00 Z M 76.21 110.00 L 114.32 88.00 M 95.26 99.00 L 114.32 110.00 L 95.26 121.00 Z"
+}, n = 44, { width: r } = e, i = r / 2;
+function a(e) {
+	return {
+		x: r * (e.q + e.r / 2),
+		y: 66 * e.r
+	};
+}
+function o(e) {
+	return {
+		x: i * e.j,
+		y: n * e.i + 22 * e.j
+	};
+}
+function s(e) {
+	let t = o(e);
+	return {
+		x: t.x,
+		y: 22 + t.y
+	};
+}
+function c(e) {
+	let { i: t, j: n } = e;
+	return e.k === 0 ? [
+		{
+			i: t,
+			j: n
+		},
+		{
+			i: t,
+			j: n + 1
+		},
+		{
+			i: t + 1,
+			j: n
+		}
+	] : [
+		{
+			i: t,
+			j: n + 1
+		},
+		{
+			i: t + 1,
+			j: n + 1
+		},
+		{
+			i: t + 1,
+			j: n
+		}
+	];
+}
+function l(e, t) {
+	let r = e - i, a = 2 / 3 * ((t - 44) / n), o = Math.sqrt(3) / 3 * (r / n) - a / 2, s = -o - a, c = Math.round(o), l = Math.round(a), u = Math.round(s), d = Math.abs(c - o), f = Math.abs(l - a), p = Math.abs(u - s);
+	return d > f && d > p ? c = -l - u : f > p && (l = -c - u), {
+		q: c + 0,
+		r: l + 0
+	};
+}
+function u(e, t) {
+	let r = Math.round(e / i);
+	return {
+		i: Math.round((t - 22 - 22 * r) / n) + 0,
+		j: r + 0
+	};
+}
+function d(e) {
+	return {
+		i: e.r - e.q,
+		j: 1 + 2 * e.q + e.r
+	};
+}
+function f(e) {
+	let t = e.j - 1 - e.i;
+	if (t % 3 != 0) return;
+	let n = t / 3;
+	return {
+		q: n + 0,
+		r: e.i + n + 0
+	};
+}
+function p(e) {
+	let { i: t, j: n } = d(e);
+	return [
+		{
+			i: t,
+			j: n,
+			k: 0
+		},
+		{
+			i: t - 1,
+			j: n,
+			k: 0
+		},
+		{
+			i: t,
+			j: n - 1,
+			k: 0
+		},
+		{
+			i: t - 1,
+			j: n,
+			k: 1
+		},
+		{
+			i: t,
+			j: n - 1,
+			k: 1
+		},
+		{
+			i: t - 1,
+			j: n - 1,
+			k: 1
+		}
+	];
+}
+function m(e) {
+	let { i: t, j: n } = e;
+	return e.k === 0 ? [
+		{
+			i: t - 1,
+			j: n,
+			k: 1
+		},
+		{
+			i: t,
+			j: n,
+			k: 1
+		},
+		{
+			i: t,
+			j: n - 1,
+			k: 1
+		}
+	] : [
+		{
+			i: t,
+			j: n + 1,
+			k: 0
+		},
+		{
+			i: t + 1,
+			j: n,
+			k: 0
+		},
+		{
+			i: t,
+			j: n,
+			k: 0
+		}
+	];
+}
+var h = (e) => `${e.i},${e.j},${e.k}`, g = (e) => `${e.i},${e.j}`, _ = (e, t) => ({
+	left: 0,
+	top: 0,
+	right: e,
+	bottom: t
+}), v = (e, t) => t.x >= e.left && t.y >= e.top && t.x <= e.right && t.y <= e.bottom, y = (e) => e.kind === "cell" ? p(e.at) : [e.at], b = /* @__PURE__ */ new WeakMap(), x = /* @__PURE__ */ new WeakMap();
+function S(e) {
+	let t = b.get(e);
+	return t || (t = e.parts.flatMap(y), b.set(e, t)), t;
+}
+function C(e) {
+	let t = x.get(e);
+	return t || (t = new Set(S(e).map(h)), x.set(e, t)), t;
+}
+function w(e, t) {
+	let n = new Set(e.flatMap(p).map(h)), r = t.map(C);
+	return (e) => {
+		let t = h(e);
+		return n.has(t) || r.some((e) => e.has(t));
+	};
+}
+function T(e, t, n, r = []) {
+	let i = w(r, t.filter((t) => t.id !== e.id));
+	return S(e).every((e) => c(e).every((e) => v(n, s(e))) && !i(e));
+}
+var E = (e) => e.parts.some((e) => e.kind === "cell");
+function D(e, t) {
+	if (t.i === 0 && t.j === 0) return e;
+	let n = (e) => ({
+		i: e.i + t.i,
+		j: e.j + t.j
+	});
+	if (E(e) && (t.j - t.i) % 3 != 0) throw Error("a piece with a cell moves a whole cell at a time");
+	let r = e.parts.map((e) => e.kind === "tri" ? {
+		...e,
+		at: {
+			...n(e.at),
+			k: e.at.k
+		}
+	} : {
+		...e,
+		at: f(n(d(e.at)))
+	}), i = {
+		...e,
+		parts: r,
+		pivot: n(e.pivot)
+	}, a = O.get(e);
+	return O.set(i, a ? {
+		from: a.from,
+		by: {
+			i: a.by.i + t.i,
+			j: a.by.j + t.j
+		}
+	} : {
+		from: e,
+		by: t
+	}), i;
+}
+var O = /* @__PURE__ */ new WeakMap();
+function k(e, t) {
+	let n = d(l(e + i, t + 44)), r = d({
+		q: 0,
+		r: 0
+	});
+	return {
+		i: n.i - r.i,
+		j: n.j - r.j
+	};
+}
+function A(e, t, n) {
+	return E(e) ? k(t, n) : u(t, n + 22);
+}
+var j = {
+	reach: .5,
+	capture: .3,
+	release: .5,
+	lean: .6
+};
+function M(e, t, n) {
+	let r = A(e, t, n);
+	if (E(e)) return r;
+	let i = [r, ...[
+		[1, 0],
+		[-1, 0],
+		[0, 1],
+		[0, -1],
+		[1, -1],
+		[-1, 1]
+	].map(([e, t]) => ({
+		i: r.i + e,
+		j: r.j + t
+	}))], a = (e) => {
+		let r = o(e);
+		return Math.hypot(t - r.x, n - r.y);
+	};
+	return i.reduce((e, t) => a(t) < a(e) ? t : e);
+}
+var N = (e) => e * e * (3 - 2 * e);
+function P(e, t, i, a) {
+	let s = (E(e) ? r : n) * j.reach;
+	if (a) {
+		let e = o(a);
+		if (Math.hypot(t - e.x, i - e.y) <= s * j.release) return {
+			step: a,
+			x: e.x,
+			y: e.y,
+			pull: 1,
+			held: a
+		};
+	}
+	let c = M(e, t, i), l = o(c), u = Math.hypot(t - l.x, i - l.y), d = s * j.capture;
+	if (u <= d) return {
+		step: c,
+		x: l.x,
+		y: l.y,
+		pull: 1,
+		held: c
+	};
+	let f = u >= s ? 0 : 1 - N((u - d) / (s - d)), p = f * j.lean;
+	return {
+		step: c,
+		x: t + (l.x - t) * p,
+		y: i + (l.y - i) * p,
+		pull: f,
+		held: void 0
+	};
+}
+function F(e, t = .12) {
+	let n = (t) => `translate(${e.x * t}px, ${e.y * t}px)`;
+	return [
+		{
+			transform: n(1),
+			offset: 0,
+			easing: "cubic-bezier(0.3, 0, 0.6, 1)"
+		},
+		{
+			transform: n(-t),
+			offset: .6,
+			easing: "ease-in-out"
+		},
+		{
+			transform: n(t * .3),
+			offset: .84,
+			easing: "ease-in-out"
+		},
+		{
+			transform: n(0),
+			offset: 1
+		}
+	];
+}
+function I(e, t) {
+	return (E(e) ? {
+		ArrowRight: {
+			i: -1,
+			j: 2
+		},
+		ArrowLeft: {
+			i: 1,
+			j: -2
+		},
+		ArrowDown: {
+			i: 1,
+			j: 1
+		},
+		ArrowUp: {
+			i: -1,
+			j: -1
+		}
+	} : {
+		ArrowRight: {
+			i: -1,
+			j: 2
+		},
+		ArrowLeft: {
+			i: 1,
+			j: -2
+		},
+		ArrowDown: {
+			i: 1,
+			j: 0
+		},
+		ArrowUp: {
+			i: -1,
+			j: 0
+		}
+	})[t];
+}
+var L = (e) => ({
+	i: e.i + e.j,
+	j: -e.i + 0
+});
+function R(e) {
+	let t = Math.min(...e.map((e) => e.i)), n = e.filter((e) => e.i === t);
+	return n.length === 2 ? {
+		i: t,
+		j: Math.min(...n.map((e) => e.j)),
+		k: 0
+	} : {
+		i: t,
+		j: n[0].j - 1,
+		k: 1
+	};
+}
+function z(e, t) {
+	let n = (t % 6 + 6) % 6, r = e.pivot, i = (e) => {
+		let t = {
+			i: e.i - r.i,
+			j: e.j - r.j
+		};
+		for (let e = 0; e < n; e++) t = L(t);
+		return {
+			i: t.i + r.i,
+			j: t.j + r.j
+		};
+	}, a = e.parts.map((e) => e.kind === "tri" ? {
+		...e,
+		at: R(c(e.at).map(i))
+	} : {
+		...e,
+		at: f(i(d(e.at)))
+	});
+	return {
+		...e,
+		parts: a
+	};
+}
+var B = (e) => s(e.pivot);
+function V(e) {
+	let t = e.flatMap(y).flatMap((e) => c(e).map(s)), n = {
+		x: t.reduce((e, t) => e + t.x, 0) / t.length,
+		y: t.reduce((e, t) => e + t.y, 0) / t.length
+	};
+	return e.some((e) => e.kind === "cell") ? d(l(n.x, n.y)) : u(n.x, n.y);
+}
+var H = (e, t) => ({
+	id: e,
+	parts: t,
+	pivot: V(t)
+});
+function U(e, t) {
+	let n = t instanceof Set ? t : new Set(t.map(h));
+	return e.some((e) => m(e).some((e) => n.has(h(e))));
+}
+var W = (e, t) => S(e).length <= S(t).length ? U(S(e), C(t)) : U(S(t), C(e));
+function G(e, t) {
+	let n = C(t), r = [];
+	for (let t of S(e)) for (let e of m(t)) {
+		if (!n.has(h(e))) continue;
+		let i = new Set(c(t).map(g)), a = c(e).filter((e) => i.has(g(e)));
+		a.length === 2 && r.push([s(a[0]), s(a[1])]);
+	}
+	return r;
+}
+function K(e) {
+	let t = /* @__PURE__ */ new Map();
+	e.parts.forEach((e, n) => {
+		for (let r of y(e)) t.set(h(r), n);
+	});
+	let n = [];
+	for (let [e, r] of t) {
+		let [i, a, o] = e.split(",").map(Number), l = {
+			i,
+			j: a,
+			k: o
+		};
+		for (let e of m(l)) {
+			let i = t.get(h(e));
+			if (i === void 0 || i <= r) continue;
+			let a = new Set(c(l).map(g)), o = c(e).filter((e) => a.has(g(e)));
+			o.length === 2 && n.push([s(o[0]), s(o[1])]);
+		}
+	}
+	return n;
+}
+function q(e, t) {
+	let n = t.filter((t) => t.id !== e.id && W(e, t)), r = [...e.parts, ...n.flatMap((e) => e.parts)];
+	return {
+		piece: H(e.id, r),
+		absorbed: n.map((e) => e.id)
+	};
+}
+function J(e, t) {
+	let n = [...e], r = [];
+	for (; n.length > 0;) {
+		let e = [n.shift()];
+		for (let t = 0; t < e.length; t++) {
+			let r = y(e[t]);
+			for (let t = n.length - 1; t >= 0; t--) U(r, y(n[t])) && e.push(...n.splice(t, 1));
+		}
+		r.push(H(t(), e));
+	}
+	return r;
+}
+function Y(e, t, n) {
+	let r = e.parts[t], i = e.parts.filter((e, n) => n !== t);
+	return [H(n(), [r]), ...J(i, n)];
+}
+var X = (e, t) => e.parts.map((e) => H(t(), [e]));
+function Z(e) {
+	return E(e) ? [
+		{
+			i: -1,
+			j: 2
+		},
+		{
+			i: 1,
+			j: -2
+		},
+		{
+			i: 1,
+			j: 1
+		},
+		{
+			i: -1,
+			j: -1
+		},
+		{
+			i: 2,
+			j: -1
+		},
+		{
+			i: -2,
+			j: 1
+		}
+	] : [
+		{
+			i: 1,
+			j: 0
+		},
+		{
+			i: -1,
+			j: 0
+		},
+		{
+			i: 0,
+			j: 1
+		},
+		{
+			i: 0,
+			j: -1
+		},
+		{
+			i: 1,
+			j: -1
+		},
+		{
+			i: -1,
+			j: 1
+		}
+	];
+}
+function Q(e, t, n, r = [], i = 6, a = () => !0) {
+	let s = Z(e), c = /* @__PURE__ */ new Set(["0,0"]), l = [{
+		i: 0,
+		j: 0
+	}];
+	for (let u = 0; u <= i; u++) {
+		let i = l.map((t) => ({
+			d: t,
+			at: D(e, t),
+			far: Math.hypot(o(t).x, o(t).y)
+		})).filter((e) => T(e.at, t, n, r) && a(e.at)).sort((e, t) => e.far - t.far);
+		if (i[0]) return i[0].at;
+		let u = [];
+		for (let e of l) for (let t of s) {
+			let n = {
+				i: e.i + t.i,
+				j: e.j + t.j
+			}, r = g(n);
+			c.has(r) || (c.add(r), u.push(n));
+		}
+		l = u;
+	}
+}
+var $ = (e) => o(e);
+function ee(e) {
+	let t = new Set(S(e).map(h)), n = [];
+	for (let r of S(e)) for (let e of m(r)) {
+		if (t.has(h(e))) continue;
+		let i = new Set(c(r).map(g)), a = c(e).filter((e) => i.has(g(e)));
+		a.length === 2 && n.push([s(a[0]), s(a[1])]);
+	}
+	return n;
+}
+function te(e, t, n, r, i) {
+	let a = l(t, n);
+	if (e === "cell") return H(i, [{
+		kind: e,
+		at: a,
+		tone: r
+	}]);
+	let { i: o, j: s } = d(a);
+	return H(i, [{
+		kind: e,
+		at: {
+			i: o - 1,
+			j: s,
+			k: 0
+		},
+		tone: r
+	}]);
+}
+function ne(e, t) {
+	let n = (e) => Math.round(e * 100) / 100, o = (e) => `M${e.map((e) => `${n(e.x)} ${n(e.y)}`).join("L")}Z`, l = (e) => ({
+		x: e.x,
+		y: e.y - t
+	}), u = /* @__PURE__ */ new Map(), d = (e, t, n) => {
+		let r = `${e}:${t}`, i = u.get(r) ?? {
+			tone: t,
+			kind: e,
+			d: []
+		};
+		i.d.push(n), u.set(r, i);
+	};
+	for (let t of e.parts) if (t.kind === "cell") {
+		let { x: e, y: n } = a(t.at), s = (t, r) => ({
+			x: e + t,
+			y: n + r
+		}), [c, u, f] = [
+			s(0, 66),
+			s(i, 88),
+			s(r, 66)
+		];
+		d("shade", t.tone, o([
+			c,
+			u,
+			l(u),
+			l(c)
+		])), d("shadow", t.tone, o([
+			u,
+			f,
+			l(f),
+			l(u)
+		])), d("top", t.tone, o([
+			s(i, 0),
+			s(r, 22),
+			s(r, 66),
+			s(i, 88),
+			s(0, 66),
+			s(0, 22)
+		].map(l)));
+	} else {
+		let e = c(t.at).map(s), n = e[2], r = e[1];
+		d(t.at.k === 0 ? "shadow" : "shade", t.tone, o([
+			n,
+			r,
+			l(r),
+			l(n)
+		])), d("top", t.tone, o(e.map(l)));
+	}
+	let f = [
+		"shade",
+		"shadow",
+		"top"
+	];
+	return {
+		faces: [...u.values()].sort((e, t) => f.indexOf(e.kind) - f.indexOf(t.kind) || e.tone - t.tone).map((e) => ({
+			tone: e.tone,
+			kind: e.kind,
+			d: e.d.join("")
+		})),
+		seams: K(e).map(([e, r]) => `M${n(e.x)} ${n(e.y - t)}L${n(r.x)} ${n(r.y - t)}`).join("")
+	};
+}
+//#endregion
+export { e as A, F as C, p as D, W as E, z as O, A as S, $ as T, B as _, s as a, K as b, T as c, l as d, P as f, H as g, ee as h, u as i, t as j, te as k, ne as l, Q as m, X as n, c as o, D as p, a as r, S as s, j as t, q as u, Y as v, I as w, G as x, _ as y };

package/dist/hexes.js

@@ -0,0 +1 @@
+export { t as MAGNET, n as apart, r as boxOf, i as cornerAt, a as cornerOf, o as cornersOf, s as covered, c as fits, u as glued, d as hexAt, f as magnetOf, p as moved, m as nearestFit, h as outlineOf, g as pieceOf, _ as pivotPoint, v as pulledOff, y as screenArea, b as seamsOf, x as sharedSides, S as snapDelta, C as snapFrames, w as stepFor, T as stepOnScreen, E as touching, D as trisOf, O as turned, k as unitAt } from "./hexes-DN9eyQho.js";

package/dist/index.js

@@ -1 +1 @@
-export { x as FACES, _ as FACE_TAG, n as HexSky, p as ICON_NAMES, m as ICON_TAG, v as LatticeFace, h as LatticeIcon, c as LatticeShape, y as MOODS, d as SHAPE_NAMES, l as SHAPE_TAG, a as SHEARS_TAG, r as SKY_TAG, o as ShearsPadElement, f as TONES, i as defineHexSky, t as defineLatticeElements, b as defineLatticeFace, g as defineLatticeIcon, u as defineLatticeShape, s as defineShearsPad } from "./elements-DMimFemm.js";
+export { x as FACES, _ as FACE_TAG, n as HexSky, p as ICON_NAMES, m as ICON_TAG, v as LatticeFace, h as LatticeIcon, c as LatticeShape, y as MOODS, d as SHAPE_NAMES, l as SHAPE_TAG, a as SHEARS_TAG, r as SKY_TAG, o as ShearsPadElement, f as TONES, i as defineHexSky, t as defineLatticeElements, b as defineLatticeFace, g as defineLatticeIcon, u as defineLatticeShape, s as defineShearsPad } from "./elements-Czlt91Ar.js";

package/dist/types/elements/hexes.d.ts

@@ -0,0 +1 @@
+export { type Area, apart, boxOf, type Corner, cornerAt, cornerOf, cornersOf, covered, fits, glued, type Hex, hexAt, MAGNET, type Magnet, magnetOf, moved, nearestFit, outlineOf, type Part, type Piece, pieceOf, pivotPoint, pulledOff, screenArea, seamsOf, sharedSides, snapDelta, snapFrames, stepFor, stepOnScreen, type Tri, touching, trisOf, turned, unitAt, } from "../hexes";

package/dist/types/elements/sky.d.ts

@@ -3,11 +3,14 @@ export declare const SKY_TAG = "hex-sky";
 export declare class HexSky extends LatticeElement {
     static readonly observedAttributes: string[];
     private readonly kindSignal;
+    private readonly orientSignal;
     private readonly scaleSignal;
     private readonly xSignal;
     private readonly ySignal;
     get kind(): "sky" | "earth";
     set kind(kind: string);
+    get orient(): "pointy" | "flat";
+    set orient(orient: string);
     get scale(): number;
     set scale(scale: number | string);
     get x(): number;

package/dist/types/hexes.d.ts

@@ -84,6 +84,47 @@ export declare function slidOf(piece: Piece): {
 export declare function cellStep(dx: number, dy: number): Corner;
 /** The step a pointer's move of (dx, dy) on the screen comes to: the nearest one the piece can take. */
 export declare function snapDelta(piece: Piece, dx: number, dy: number): Corner;
+/**
+ * How the slots pull, as parts of a piece's unit (a cell across, or a triangle's side): how far a
+ * slot reaches, how near catches and holds, how far a held piece must be tugged to come free (more
+ * than catches it, so it never flickers at the edge), and how far it leans in before it is caught.
+ */
+export declare const MAGNET: {
+    readonly reach: 0.5;
+    readonly capture: 0.3;
+    readonly release: 0.5;
+    readonly lean: 0.6;
+};
+/** Where a carried piece is drawn, and the slot it would land in. */
+export interface Magnet {
+    /** The slot: the step from where the piece was lifted. */
+    step: Corner;
+    /** Where to draw it, as a move from where it was lifted, on the screen. */
+    x: number;
+    y: number;
+    /** How hard the slot pulls, 0 to 1: 1 while held. */
+    pull: number;
+    /** The slot it is held in, to hand back on the next move; none while it only leans. */
+    held: Corner | undefined;
+}
+/**
+ * A carried piece moved (dx, dy) by the pointer since it was lifted, and held in `held` before:
+ * where it is drawn and where it would land. Near a slot it leans in; nearer, the slot catches it
+ * and it is drawn there exactly; it stays caught until it is tugged past `MAGNET.release`.
+ */
+export declare function magnetOf(piece: Piece, dx: number, dy: number, held?: Corner): Magnet;
+/**
+ * The click into a slot: keyframes (Web Animations) that bring a piece from `from` (how far it is
+ * off, on the screen) to rest, passing it by `overshoot` of the way and settling back.
+ */
+export declare function snapFrames(from: {
+    x: number;
+    y: number;
+}, overshoot?: number): {
+    transform: string;
+    offset: number;
+    easing?: string;
+}[];
 /** How the arrow keys step a piece: a cell, or a triangle's side, in each direction. */
 export declare function stepFor(piece: Piece, key: string): Corner | undefined;
 /** The piece turned `turns` sixths clockwise (negative: anticlockwise) about its pivot. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harmonics/lattice-ui",
-  "version": "0.1.0",
+  "version": "0.5.0",
   "description": "The Harmonics tree's look as Custom Elements: a lattice face, the hexagon sky, raised lattice shapes, a shears cut gesture and two marks. Any page, any framework.",
   "license": "MIT",
   "type": "module",
@@ -16,6 +16,10 @@
       "types": "./dist/types/elements/define.d.ts",
       "default": "./dist/define.js"
     },
+    "./hexes": {
+      "types": "./dist/types/elements/hexes.d.ts",
+      "default": "./dist/hexes.js"
+    },
     "./react": {
       "types": "./react.d.ts"
     },
@@ -42,6 +46,6 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Blankenship-Daniel/harmonics.git",
-    "directory": "experiments/tree-alt/kit"
+    "directory": "packages/lattice-ui/kit"
   }
 }