@mark1russell7/layout-contract 0.0.0-stage → 0.2.1

package/build/index.js

@@ -0,0 +1,584 @@
+// src/geometry.ts
+/** The sides in clockwise order, from the top. */
+const SIDES = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+/** This function gives the value of each side of a margin. No margin gives 0 on each side. */
+function marginSides(margin) {
+	if (margin === void 0) return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	if (typeof margin === "number") return {
+		top: margin,
+		right: margin,
+		bottom: margin,
+		left: margin
+	};
+	return margin;
+}
+/** This function gives the rectangle made larger by the margin on each side. */
+function grow(rect, margin) {
+	const m = marginSides(margin);
+	return {
+		x: rect.x - m.left,
+		y: rect.y - m.top,
+		w: rect.w + m.left + m.right,
+		h: rect.h + m.top + m.bottom
+	};
+}
+/** This function gives the bounding box of a region. */
+function boundsOf(region) {
+	switch (region.kind) {
+		case "rect": return {
+			x: region.x,
+			y: region.y,
+			w: region.w,
+			h: region.h
+		};
+		case "circle": return {
+			x: region.cx - region.r,
+			y: region.cy - region.r,
+			w: 2 * region.r,
+			h: 2 * region.r
+		};
+		case "ellipse": return {
+			x: region.cx - region.rx,
+			y: region.cy - region.ry,
+			w: 2 * region.rx,
+			h: 2 * region.ry
+		};
+		case "polygon": {
+			let x0 = Infinity;
+			let y0 = Infinity;
+			let x1 = -Infinity;
+			let y1 = -Infinity;
+			for (const [x, y] of region.points) {
+				x0 = Math.min(x0, x);
+				y0 = Math.min(y0, y);
+				x1 = Math.max(x1, x);
+				y1 = Math.max(y1, y);
+			}
+			return {
+				x: x0,
+				y: y0,
+				w: x1 - x0,
+				h: y1 - y0
+			};
+		}
+	}
+}
+/** This function gives the region moved by `dx` and `dy`. */
+function translate(region, dx, dy) {
+	switch (region.kind) {
+		case "rect": return {
+			...region,
+			x: region.x + dx,
+			y: region.y + dy
+		};
+		case "circle":
+		case "ellipse": return {
+			...region,
+			cx: region.cx + dx,
+			cy: region.cy + dy
+		};
+		case "polygon": {
+			const move = (ring) => ring.map(([x, y]) => [x + dx, y + dy]);
+			return region.holes === void 0 ? {
+				kind: "polygon",
+				points: move(region.points)
+			} : {
+				kind: "polygon",
+				points: move(region.points),
+				holes: region.holes.map(move)
+			};
+		}
+	}
+}
+/**
+* This function gives the overlap of the insides of two rectangles on each axis.
+* A value of 0 or less on an axis is no overlap. Two rectangles with a common edge have an overlap of 0.
+*/
+function overlapOf(a, b) {
+	return {
+		x: Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x),
+		y: Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y)
+	};
+}
+// src/tolerance.ts
+/** The epsilon for the float compares in an engine. */
+const EPS = 1e-6;
+/**
+* The epsilon for the float compares on a written file. A file rounds each number to 3 decimals,
+* so a difference of two values can move by up to 0.001.
+*/
+const RECORD_EPS = .001;
+/**
+* The default tolerance of each rule. The packer is exact, so `overlap` is one unit of the rounding.
+* Routes are sampled curves that follow the margin line, so `through` is larger.
+*/
+const DEFAULT_TOLERANCE = Object.freeze({
+	overlap: .001,
+	through: .5
+});
+// src/input.ts
+/** This function gives the packer input of a file. An input without a container gets `{ fixed: "none" }`, so the packer picks the size. */
+function toPackInput(input) {
+	return {
+		container: input.container ?? { fixed: "none" },
+		items: input.boxes,
+		...input.obstacles === void 0 ? {} : { obstacles: input.obstacles },
+		...input.gap === void 0 ? {} : { gap: input.gap }
+	};
+}
+// src/turn.ts
+/** This function gives the side after a turn of 90 degrees clockwise. */
+function turnSide(side) {
+	return SIDES[(SIDES.indexOf(side) + 1) % 4];
+}
+/** This function gives a point of a box of height `h` after the turn. */
+function turnPoint(x, y, h) {
+	return [h - y, x];
+}
+/** This function gives a port of a box of height `h` after the turn. Each value of the port turns, also a port with only `x` or only `y`. */
+function turnPort(port, h) {
+	const { side, x, y, ...rest } = port;
+	return {
+		...rest,
+		...side === void 0 ? {} : { side: turnSide(side) },
+		...y === void 0 ? {} : { x: h - y },
+		...x === void 0 ? {} : { y: x }
+	};
+}
+/** This function gives a margin after the turn: the value of each side moves one side clockwise. */
+function turnMargin(margin) {
+	if (typeof margin === "number") return margin;
+	const m = marginSides(margin);
+	return {
+		top: m.left,
+		right: m.top,
+		bottom: m.right,
+		left: m.bottom
+	};
+}
+/** This function gives a region relative to the origin of a box of height `h` after the turn. */
+function turnRegion(region, h) {
+	switch (region.kind) {
+		case "rect": return {
+			kind: "rect",
+			x: h - region.y - region.h,
+			y: region.x,
+			w: region.h,
+			h: region.w
+		};
+		case "circle": return {
+			...region,
+			cx: h - region.cy,
+			cy: region.cx
+		};
+		case "ellipse": return {
+			kind: "ellipse",
+			cx: h - region.cy,
+			cy: region.cx,
+			rx: region.ry,
+			ry: region.rx
+		};
+		case "polygon": {
+			const turn = (ring) => ring.map(([x, y]) => turnPoint(x, y, h));
+			return region.holes === void 0 ? {
+				kind: "polygon",
+				points: turn(region.points)
+			} : {
+				kind: "polygon",
+				points: turn(region.points),
+				holes: region.holes.map(turn)
+			};
+		}
+	}
+}
+/** This function gives a box after the turn: the size, the ports, the margin and the shape turn. The position stays. */
+function turnBox(box) {
+	return {
+		...box,
+		w: box.h,
+		h: box.w,
+		...box.ports === void 0 ? {} : { ports: box.ports.map((p) => turnPort(p, box.h)) },
+		...box.margin === void 0 ? {} : { margin: turnMargin(box.margin) },
+		...box.shape === void 0 ? {} : { shape: turnRegion(box.shape, box.h) }
+	};
+}
+// src/output.ts
+/**
+* This function gives the input with the output of a packer applied. Each placed box gets its position.
+* A turned box gets its turned size, ports, margin and shape. Each moved obstacle moves.
+* The container gets the size of the output. The router reads this result. It does not read `turn`.
+*/
+function applyPack(input, output) {
+	const at = new Map(output.placements.map((p) => [p.id, p]));
+	const moved = new Map(output.moved.map((m) => [m.id, m]));
+	const boxes = input.boxes.map((box) => {
+		const p = at.get(box.id);
+		if (p === void 0) return box;
+		return {
+			...p.turn === 90 ? turnBox(box) : box,
+			x: p.x,
+			y: p.y
+		};
+	});
+	const obstacles = input.obstacles?.map((o) => {
+		const m = moved.get(o.id);
+		if (m === void 0) return o;
+		const b = boundsOf(o.region);
+		return {
+			...o,
+			region: translate(o.region, m.x - b.x, m.y - b.y)
+		};
+	});
+	return {
+		...input,
+		container: {
+			...input.container ?? { fixed: "none" },
+			w: output.size.w,
+			h: output.size.h
+		},
+		boxes,
+		...obstacles === void 0 ? {} : { obstacles }
+	};
+}
+// src/record.ts
+/** This function gives the record of a run. The input gives its id, its hash, its set and the counts of the nodes and the edges. */
+function toLayoutRecord(input, run) {
+	return {
+		schema: "layout-record/1",
+		...run,
+		input: input.id,
+		inputHash: input.hash ?? "",
+		set: input.set ?? "",
+		nodes: input.boxes.length,
+		edges: input.edges?.length ?? 0
+	};
+}
+// src/rules.ts
+/** This function gives the area of a placed box: its shape or its rectangle, at its position. A box without a position gives `undefined`. */
+function placedRect(box) {
+	if (box.x === void 0 || box.y === void 0) return void 0;
+	if (box.shape === void 0) return {
+		x: box.x,
+		y: box.y,
+		w: box.w,
+		h: box.h
+	};
+	const b = boundsOf(box.shape);
+	return {
+		x: box.x + b.x,
+		y: box.y + b.y,
+		w: b.w,
+		h: b.h
+	};
+}
+/**
+* This function counts the pairs of placed boxes whose insides, with their margins, overlap by more than `tolerance` on each axis.
+* A box with a shape counts as its bounding box. That area is larger, thus the count is safe.
+*/
+function countOverlaps(boxes, tolerance = DEFAULT_TOLERANCE.overlap) {
+	const rects = [];
+	for (const box of boxes) {
+		const r = placedRect(box);
+		if (r !== void 0) rects.push(grow(r, box.margin));
+	}
+	rects.sort((a, b) => a.x - b.x);
+	let count = 0;
+	for (let i = 0; i < rects.length; i++) {
+		const a = rects[i];
+		for (let j = i + 1; j < rects.length; j++) {
+			const b = rects[j];
+			if (b.x >= a.x + a.w - tolerance) break;
+			const o = overlapOf(a, b);
+			if (o.x > tolerance && o.y > tolerance) count++;
+		}
+	}
+	return count;
+}
+/**
+* This function counts the placed boxes that go out of the container.
+* Each box with its margin must stay inside the container made smaller by `inset`. Only the fixed sides of the size count. A shaped container counts as its bounding box.
+* An input without a container gives 0.
+*/
+function countOutside(input, tolerance = DEFAULT_TOLERANCE.overlap) {
+	const c = input.container;
+	if (c === void 0) return 0;
+	const area = c.shape === void 0 ? {
+		x: 0,
+		y: 0,
+		w: c.w ?? Infinity,
+		h: c.h ?? Infinity
+	} : boundsOf(c.shape);
+	const inset = c.inset ?? 0;
+	const fixW = c.fixed === "size" || c.fixed === "width";
+	const fixH = c.fixed === "size" || c.fixed === "height";
+	let count = 0;
+	for (const box of input.boxes) {
+		const r0 = placedRect(box);
+		if (r0 === void 0) continue;
+		const r = grow(r0, box.margin);
+		const outX = r.x < area.x + inset - tolerance || r.x + r.w > area.x + area.w - inset + tolerance;
+		const outY = r.y < area.y + inset - tolerance || r.y + r.h > area.y + area.h - inset + tolerance;
+		if (fixW && outX || fixH && outY) count++;
+	}
+	return count;
+}
+/** This function counts the fixed ports that are not on the border of their box, with the epsilon of a written file. A port without a side does not count. */
+function countPortsOffBorder(boxes, eps = RECORD_EPS) {
+	let count = 0;
+	for (const box of boxes) for (const p of box.ports ?? []) {
+		if (p.x === void 0 || p.y === void 0 || p.side === void 0) continue;
+		const along = p.side === "top" || p.side === "bottom" ? p.x : p.y;
+		const length = p.side === "top" || p.side === "bottom" ? box.w : box.h;
+		const across = {
+			top: p.y,
+			bottom: p.y - box.h,
+			left: p.x,
+			right: p.x - box.w
+		}[p.side];
+		if (Math.abs(across) > eps || along < -eps || along > length + eps) count++;
+	}
+	return count;
+}
+/** This function tells if the inside of `region` and the inside of `rect` have a common point. */
+function regionHitsRect(region, rect) {
+	if (rect.w <= 0 || rect.h <= 0) return false;
+	switch (region.kind) {
+		case "rect": {
+			const o = overlapOf(region, rect);
+			return o.x > 0 && o.y > 0;
+		}
+		case "circle": return circleHitsRect(region.cx, region.cy, region.r, region.r, rect);
+		case "ellipse": return circleHitsRect(region.cx, region.cy, region.rx, region.ry, rect);
+		case "polygon": {
+			const rings = [region.points, ...region.holes ?? []];
+			const inside = (x, y) => x > rect.x && x < rect.x + rect.w && y > rect.y && y < rect.y + rect.h;
+			if (region.points.some(([x, y]) => inside(x, y))) return true;
+			for (const ring of rings) for (let i = 0; i < ring.length; i++) {
+				const a = ring[i];
+				const b = ring[(i + 1) % ring.length];
+				const m = clipMid(a[0], a[1], b[0], b[1], rect);
+				if (m !== void 0 && inside(m[0], m[1])) return true;
+			}
+			return pointInRings(rect.x + rect.w / 2, rect.y + rect.h / 2, rings);
+		}
+	}
+}
+/** An ellipse with the radii `rx` and `ry` scales to a unit circle. The rectangle scales with it. */
+function circleHitsRect(cx, cy, rx, ry, rect) {
+	if (rx <= 0 || ry <= 0) return false;
+	const x0 = (rect.x - cx) / rx;
+	const x1 = (rect.x + rect.w - cx) / rx;
+	const y0 = (rect.y - cy) / ry;
+	const y1 = (rect.y + rect.h - cy) / ry;
+	const dx = Math.max(x0, 0, -x1);
+	const dy = Math.max(y0, 0, -y1);
+	return dx * dx + dy * dy < 1;
+}
+/** This function gives the middle of the part of a segment inside a rectangle, or `undefined` when that part is a point or empty. */
+function clipMid(ax, ay, bx, by, r) {
+	let t0 = 0;
+	let t1 = 1;
+	const dx = bx - ax;
+	const dy = by - ay;
+	const edges = [
+		[-dx, ax - r.x],
+		[dx, r.x + r.w - ax],
+		[-dy, ay - r.y],
+		[dy, r.y + r.h - ay]
+	];
+	for (const [p, q] of edges) if (p === 0) {
+		if (q < 0) return void 0;
+	} else if (p < 0) t0 = Math.max(t0, q / p);
+	else t1 = Math.min(t1, q / p);
+	if (t1 <= t0) return void 0;
+	const t = (t0 + t1) / 2;
+	return [ax + t * dx, ay + t * dy];
+}
+/** The even-odd rule over the outer ring and the holes. */
+function pointInRings(x, y, rings) {
+	let inside = false;
+	for (const ring of rings) for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+		const [xi, yi] = ring[i];
+		const [xj, yj] = ring[j];
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+/**
+* This function counts the pairs of a placed box and an obstacle that overlap by more than `tolerance`.
+* The box counts with its margin. A box with a shape counts as its bounding box.
+*/
+function countObstacleHits(boxes, obstacles, tolerance = DEFAULT_TOLERANCE.overlap) {
+	if (obstacles === void 0 || obstacles.length === 0) return 0;
+	let count = 0;
+	for (const box of boxes) {
+		const r0 = placedRect(box);
+		if (r0 === void 0) continue;
+		const r = grow(r0, box.margin);
+		const small = {
+			x: r.x + tolerance,
+			y: r.y + tolerance,
+			w: r.w - 2 * tolerance,
+			h: r.h - 2 * tolerance
+		};
+		for (const o of obstacles) if (regionHitsRect(o.region, small)) count++;
+	}
+	return count;
+}
+/**
+* This function gives the count of each hard rule of the output of a packer.
+* It applies the output with `applyPack`. Only the placed boxes and the locked boxes count for the overlaps and the container.
+* `no-overlap` counts the pairs of boxes and the pairs of a box and an obstacle.
+* A locked box without a placement, or with a move of more than `RECORD_EPS`, breaks `locked-kept`.
+* A locked box without a position in the input is a bad input, not a break. `checkInput` finds it.
+* Another box without a placement that is not in `overflow` breaks `complete`.
+*/
+function packHard(input, output, tolerance = DEFAULT_TOLERANCE.overlap) {
+	const after = applyPack(input, output);
+	const placed = new Set(output.placements.map((p) => p.id));
+	const out = new Set(output.overflow);
+	const was = new Map(input.boxes.map((b) => [b.id, b]));
+	let lockedMoved = 0;
+	let incomplete = 0;
+	const kept = [];
+	for (const box of after.boxes) {
+		const old = was.get(box.id);
+		if (old?.locked === true) {
+			if (old.x === void 0 || old.y === void 0) continue;
+			const moved = Math.abs(old.x - (box.x ?? old.x)) > .001 || Math.abs(old.y - (box.y ?? old.y)) > .001;
+			if (!placed.has(box.id) || moved) lockedMoved++;
+			kept.push(box);
+		} else if (placed.has(box.id)) kept.push(box);
+		else if (!out.has(box.id)) incomplete++;
+	}
+	return {
+		"no-overlap": countOverlaps(kept, tolerance) + countObstacleHits(kept, after.obstacles, tolerance),
+		"in-container": countOutside({
+			...after,
+			boxes: kept
+		}, tolerance),
+		"locked-kept": lockedMoved,
+		complete: incomplete
+	};
+}
+/**
+* This function gives the problems of an input file. An empty list tells that the file is good.
+* A problem is a bad input, not a break of a hard rule. Thus an engine refuses the input.
+*/
+function checkInput(input) {
+	const problems = [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const box of input.boxes) {
+		if (ids.has(box.id)) problems.push(`box ${box.id}: the id is not unique`);
+		ids.add(box.id);
+		if (!(box.w > 0 && box.h > 0 && Number.isFinite(box.w) && Number.isFinite(box.h))) problems.push(`box ${box.id}: the size is not positive and finite`);
+		if (box.locked === true && (box.x === void 0 || box.y === void 0)) problems.push(`box ${box.id}: a locked box has no position`);
+	}
+	if (countPortsOffBorder(input.boxes) > 0) problems.push("a fixed port is not on the border of its box");
+	for (const edge of input.edges ?? []) if (!ids.has(edge.source) || !ids.has(edge.target)) problems.push(`edge ${edge.id}: a box of the edge is not in the input`);
+	return problems;
+}
+// src/measures.ts
+/** The specs of the joint measures, in the order of `docs/JOINT-MEASURES.md`. */
+const JOINT_MEASURES = Object.freeze([
+	{
+		id: "joint.fill",
+		unit: "0 to 1",
+		direction: "higher",
+		min: 0,
+		max: 1,
+		floor: 1,
+		role: "guard"
+	},
+	{
+		id: "joint.aspectError",
+		unit: "natural log",
+		direction: "lower",
+		min: 0,
+		max: Infinity,
+		floor: 0,
+		tol: .01,
+		role: "guard"
+	},
+	{
+		id: "joint.spill",
+		unit: "0 to 1",
+		direction: "lower",
+		min: 0,
+		max: 1,
+		floor: 0,
+		tol: .001,
+		role: "guard"
+	},
+	{
+		id: "joint.straight.crossings",
+		unit: "count",
+		direction: "lower",
+		min: 0,
+		max: Infinity,
+		floor: 0,
+		tol: 0,
+		role: "guard"
+	},
+	{
+		id: "joint.straight.length",
+		unit: "S for each edge",
+		direction: "lower",
+		min: 0,
+		max: Infinity,
+		floor: 0,
+		tol: .01,
+		role: "guard"
+	},
+	{
+		id: "joint.stability.mean",
+		unit: "W",
+		direction: "lower",
+		min: 0,
+		max: Infinity,
+		floor: 0,
+		tol: .005,
+		role: "change-guard"
+	},
+	{
+		id: "joint.stability.moved",
+		unit: "0 to 1",
+		direction: "lower",
+		min: 0,
+		max: 1,
+		floor: 0,
+		tol: .02,
+		role: "change-guard"
+	},
+	{
+		id: "joint.proxy.rank",
+		unit: "-1 to 1",
+		direction: "higher",
+		min: -1,
+		max: 1,
+		role: "diagnostic"
+	},
+	{
+		id: "joint.ms",
+		unit: "milliseconds",
+		direction: "lower",
+		min: 0,
+		max: Infinity,
+		role: "time"
+	}
+]);
+/** The threshold of `joint.stability.moved`, in widths `W` of the base. */
+const JOINT_MOVED_MIN = .01;
+export { DEFAULT_TOLERANCE, EPS, JOINT_MEASURES, JOINT_MOVED_MIN, RECORD_EPS, SIDES, applyPack, boundsOf, checkInput, countObstacleHits, countOutside, countOverlaps, countPortsOffBorder, grow, marginSides, overlapOf, packHard, placedRect, regionHitsRect, toLayoutRecord, toPackInput, translate, turnBox, turnMargin, turnPoint, turnPort, turnRegion, turnSide };
+
+//# sourceMappingURL=index.js.map