@harmonics/lattice-ui 0.1.0 → 0.4.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-BJBhL4LI.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/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.4.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"
   }
 }