pattapatta 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.4.1
+
+### Patch Changes
+
+- 170d279: Docs polish: Shiki syntax highlighting (Catppuccin), slate theme, sidebar logo, sponsor badge layout, and remove the sidebar collapse control.
+
+## 0.4.0
+
+### Minor Changes
+
+- e828df4: Add `createSponge`, `hilbertSort`, `findShortestTour`, and `arcDivision`, plus plotter hatch fills (`weave` / `stochastic` / `perpendicular` / `concentric`). Refresh contour docs examples with shapes that show skeletons and fields clearly.
+
 ## 0.3.0
 
 ### Minor Changes

package/README.md

@@ -1,9 +1,14 @@
 # pattapatta
 
+[![Sponsor](https://img.shields.io/badge/Sponsor-GitHub-ea4aaa?logo=githubsponsors&logoColor=white)](https://github.com/sponsors/MadOrkestra)
+[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?logo=buymeacoffee&logoColor=black)](https://www.buymeacoffee.com/madorkestra)
+
 Pen-plotter geometry library (inspired by [PGS](https://github.com/micycle1/PGS)): hatching, circle packing, triangulation / meshing, boolean path ops, Voronoi, tilings, and SVG I/O for Node and the browser.
 
 **Stroke marks only** — solid area fills are not the goal.
 
+> **Status:** Built entirely with AI as an experiment. **Not meant for public / production use yet.** Feedback welcome via [GitHub issues](https://github.com/MadOrkestra/pattapatta/issues) on the [repository](https://github.com/MadOrkestra/pattapatta).
+
 [![npm](https://img.shields.io/npm/v/pattapatta.svg)](https://www.npmjs.com/package/pattapatta)
 
 ## Install
@@ -61,3 +66,5 @@ pnpm docs:examples   # regenerate SVG figures
 ## License
 
 MIT — clean-room implementation (not a GPL line-port of PGS). See `docs/decisions/`.
+
+Source: [github.com/MadOrkestra/pattapatta](https://github.com/MadOrkestra/pattapatta) · [Issues](https://github.com/MadOrkestra/pattapatta/issues) · [Sponsor](https://github.com/sponsors/MadOrkestra) · [Buy Me a Coffee](https://www.buymeacoffee.com/madorkestra)

package/dist/{circle-BDbKfrdR.d.ts → circle-CauDMv8V.d.ts}

@@ -1,4 +1,4 @@
-import { V as Vec2 } from './vec2-CWyXN1Wj.js';
+import { V as Vec2 } from './path-Boeshk9L.js';
 
 /** Circle with center (x, y) and radius r (PGS often stored radius in PVector.z). */
 type Circle = {

package/dist/circlePacking/index.d.ts

@@ -1,6 +1,5 @@
-import { V as Vec2 } from '../vec2-CWyXN1Wj.js';
-import { C as Circle } from '../circle-BDbKfrdR.js';
-import { P as Path } from '../path-0RjhYjJs.js';
+import { P as Path, V as Vec2 } from '../path-Boeshk9L.js';
+import { C as Circle } from '../circle-CauDMv8V.js';
 
 /**
  * Lattice inclusion mode.

package/dist/construction/index.d.ts

@@ -1,5 +1,5 @@
-import { P as Path } from '../path-0RjhYjJs.js';
-import '../vec2-CWyXN1Wj.js';
+import { P as Path } from '../path-Boeshk9L.js';
+import { G as Group } from '../group-YVmSJuGo.js';
 
 /** Regular n-gon approximating a circle. */
 declare function createCircle(cx: number, cy: number, radius: number, segments?: number): Path;
@@ -13,6 +13,13 @@ declare function createArc(cx: number, cy: number, radius: number, startAngle: n
 declare function createStar(cx: number, cy: number, outerRadius: number, innerRadius: number, points?: number, rotation?: number): Path;
 /** Koch snowflake after `iterations` refinement (0 = equilateral triangle). */
 declare function createKochSnowflake(cx: number, cy: number, radius: number, iterations?: number): Path;
+/**
+ * Sponge-like porous structure (PGS `createSponge`).
+ * Voronoi cells are randomly class-merged, smoothed (Chaikin), optionally
+ * eroded for wall thickness, then subtracted from the bounding rectangle.
+ * Returns a group (may be multi-component).
+ */
+declare function createSponge(width: number, height: number, generators: number, thickness: number, smoothing: number, classes: number, seed?: number): Group;
 declare const construction: {
     createCircle: typeof createCircle;
     createRect: typeof createRect;
@@ -21,6 +28,7 @@ declare const construction: {
     createArc: typeof createArc;
     createStar: typeof createStar;
     createKochSnowflake: typeof createKochSnowflake;
+    createSponge: typeof createSponge;
 };
 
-export { construction, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createStar };
+export { construction, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createSponge, createStar };

package/dist/construction/index.js

@@ -1,7 +1,16 @@
+import { Delaunay } from 'd3-delaunay';
+import { FillRule, JoinType, inflatePathsD, EndType, isPositiveD, differenceD, pointInPolygonD, PointInPolygonResult, unionD, areaD } from 'clipper2-ts';
+
 // src/types/vec2.ts
+function vec2(x, y) {
+  return { x, y };
+}
 function cloneVec2(v) {
   return { x: v.x, y: v.y };
 }
+function equalsVec2(a, b, eps = 1e-9) {
+  return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps;
+}
 
 // src/types/path.ts
 function path(rings, closed = true) {
@@ -16,6 +25,379 @@ function polyline(points) {
 function polygon(exterior, holes = []) {
   return path([exterior, ...holes], true);
 }
+function normalizeRing(ring, eps = 1e-9) {
+  if (ring.length < 2) return ring.map(cloneVec2);
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first && last && equalsVec2(first, last, eps)) {
+    return ring.slice(0, -1).map(cloneVec2);
+  }
+  return ring.map(cloneVec2);
+}
+function clonePath(p) {
+  return {
+    closed: p.closed,
+    rings: p.rings.map((ring) => ring.map(cloneVec2))
+  };
+}
+
+// src/types/group.ts
+function group(paths = []) {
+  return { paths: paths.map(clonePath) };
+}
+var DEFAULT_FILL_RULE = FillRule.NonZero;
+function ringToPathD(ring) {
+  const pts = [];
+  for (const v of normalizeRing(ring)) {
+    pts.push({ x: v.x, y: v.y, z: 0 });
+  }
+  return pts;
+}
+function pathToPathsD(p) {
+  if (!p.closed || p.rings.length === 0) {
+    throw new Error("Boolean ops require a closed path with at least one ring");
+  }
+  return p.rings.map((ring) => ringToPathD(ring));
+}
+function pathsDToGroup(paths) {
+  if (paths.length === 0) return group([]);
+  const outers = [];
+  const holes = [];
+  for (const pd of paths) {
+    const ring = pathDToRing(pd);
+    if (ring.length < 3) continue;
+    if (isPositiveD(pd)) {
+      outers.push({ ring, holes: [] });
+    } else {
+      holes.push(ring);
+    }
+  }
+  for (const hole of holes) {
+    const sample = hole[0];
+    if (!sample) continue;
+    let assigned = false;
+    for (const outer of outers) {
+      if (pointInRing(sample, outer.ring)) {
+        outer.holes.push(hole);
+        assigned = true;
+        break;
+      }
+    }
+    if (!assigned) {
+      outers.push({ ring: [...hole].reverse(), holes: [] });
+    }
+  }
+  return group(outers.map((o) => path([o.ring, ...o.holes], true)));
+}
+function pathDToRing(pd) {
+  return normalizeRing(pd.map((p) => vec2(p.x, p.y)));
+}
+function pointInRing(point, ring) {
+  const result = pointInPolygonD(
+    { x: point.x, y: point.y, z: 0 },
+    ringToPathD(ring)
+  );
+  return result === PointInPolygonResult.IsInside || result === PointInPolygonResult.IsOn;
+}
+function clipUnion(a, b) {
+  return unionD(a, b, DEFAULT_FILL_RULE);
+}
+function clipDifference(a, b) {
+  return differenceD(a, b, DEFAULT_FILL_RULE);
+}
+function pathsArea(paths) {
+  let sum = 0;
+  for (const p of paths) {
+    sum += Math.abs(areaD(p));
+  }
+  return sum;
+}
+
+// src/predicates/index.ts
+function ringArea(ring) {
+  if (ring.length < 3) return 0;
+  let sum = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function area(p) {
+  if (!p.closed || p.rings.length === 0) return 0;
+  try {
+    return pathsArea(pathToPathsD(p));
+  } catch {
+    let total = 0;
+    for (let i = 0; i < p.rings.length; i++) {
+      const a = Math.abs(ringArea(p.rings[i]));
+      total += i === 0 ? a : -a;
+    }
+    return Math.max(0, total);
+  }
+}
+
+// src/shapeBoolean/index.ts
+function ensureClosed(p) {
+  if (!p.closed) {
+    throw new Error("shapeBoolean requires closed paths");
+  }
+  return p;
+}
+function union(a, b) {
+  const result = clipUnion(pathToPathsD(ensureClosed(a)), pathToPathsD(ensureClosed(b)));
+  return pathsDToGroup(result);
+}
+function subtractAll(base, shapes) {
+  let acc = pathToPathsD(ensureClosed(base));
+  for (const s of shapes) {
+    acc = clipDifference(acc, pathToPathsD(ensureClosed(s)));
+  }
+  return pathsDToGroup(acc);
+}
+
+// src/voronoi/index.ts
+function compoundVoronoi(sites, options = {}) {
+  if (sites.length === 0) return group([]);
+  if (sites.length === 1) {
+    const b2 = options.bounds ?? padBounds(sites, 1);
+    return group([
+      polygon([
+        { x: b2.minX, y: b2.minY },
+        { x: b2.maxX, y: b2.minY },
+        { x: b2.maxX, y: b2.maxY },
+        { x: b2.minX, y: b2.maxY }
+      ])
+    ]);
+  }
+  const b = options.bounds ?? padBounds(sites, 0.1);
+  const delaunay = Delaunay.from(
+    sites,
+    (d) => d.x,
+    (d) => d.y
+  );
+  const voronoi = delaunay.voronoi([b.minX, b.minY, b.maxX, b.maxY]);
+  const paths = [];
+  for (let i = 0; i < sites.length; i++) {
+    const poly = voronoi.cellPolygon(i);
+    if (!poly || poly.length < 3) continue;
+    const ring = poly.slice(0, -1).map(([x, y]) => ({ x, y }));
+    if (ring.length >= 3) paths.push(polygon(ring));
+  }
+  return group(paths);
+}
+function padBounds(sites, padRatio) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const s of sites) {
+    minX = Math.min(minX, s.x);
+    minY = Math.min(minY, s.y);
+    maxX = Math.max(maxX, s.x);
+    maxY = Math.max(maxY, s.y);
+  }
+  const pad = Math.max(maxX - minX, maxY - minY, 1) * padRatio + 1e-6;
+  return {
+    minX: minX - pad,
+    minY: minY - pad,
+    maxX: maxX + pad,
+    maxY: maxY + pad
+  };
+}
+function buffer(path2, delta, options = {}) {
+  const subject = pathToPathsD(path2);
+  const join = options.join === "miter" ? JoinType.Miter : options.join === "square" ? JoinType.Square : JoinType.Round;
+  const inflated = inflatePathsD(subject, delta, join, EndType.Polygon);
+  return pathsDToGroup(inflated);
+}
+
+// src/morphology/index.ts
+function chaikinCut(p, iterations = 1, ratio = 0.25) {
+  const r = Math.min(0.49, Math.max(0.01, ratio));
+  let rings = p.rings;
+  for (let i = 0; i < Math.max(1, Math.floor(iterations)); i++) {
+    rings = rings.map((ring) => chaikinRing(ring, r, p.closed));
+  }
+  return path(rings, p.closed);
+}
+function smooth(p, iterations = 2) {
+  return chaikinCut(p, iterations);
+}
+function chaikinRing(ring, ratio, closed) {
+  if (ring.length < 2) return ring.map((v) => ({ ...v }));
+  const out = [];
+  const n = ring.length;
+  const edges = closed ? n : n - 1;
+  for (let i = 0; i < edges; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    out.push({
+      x: a.x * (1 - ratio) + b.x * ratio,
+      y: a.y * (1 - ratio) + b.y * ratio
+    });
+    out.push({
+      x: a.x * ratio + b.x * (1 - ratio),
+      y: a.y * ratio + b.y * (1 - ratio)
+    });
+  }
+  if (!closed) {
+    out.unshift({ ...ring[0] });
+    out.push({ ...ring[n - 1] });
+  }
+  return closed ? normalizeRing(out) : out;
+}
+
+// src/meshing/index.ts
+function edgeKey(a, b) {
+  const aKey = `${a.x},${a.y}`;
+  const bKey = `${b.x},${b.y}`;
+  return aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
+}
+function vertKey(v) {
+  return `${v.x},${v.y}`;
+}
+function unique(points) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of points) {
+    const k = vertKey(p);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push({ ...p });
+  }
+  return out;
+}
+function cross(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function ringOf(face) {
+  return face.rings[0] ?? [];
+}
+function buildEdgeMap(faces) {
+  const edges = /* @__PURE__ */ new Map();
+  faces.forEach((f, fi) => {
+    const ring = ringOf(f);
+    if (ring.length < 2) return;
+    const n = ring.length;
+    const closed = f.closed !== false && n >= 3;
+    const lim = closed ? n : n - 1;
+    for (let i = 0; i < lim; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % n];
+      const key = edgeKey(a, b);
+      const rec = edges.get(key);
+      if (rec) rec.faceIds.push(fi);
+      else edges.set(key, { a: { ...a }, b: { ...b }, faceIds: [fi] });
+    }
+  });
+  return edges;
+}
+function faceAdjacency(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const adj = faces.map(() => []);
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length === 2) {
+      const [i, j] = e.faceIds;
+      adj[i].push(j);
+      adj[j].push(i);
+    }
+  }
+  return adj;
+}
+function stochasticMerge(faces, nClasses, seed = 1) {
+  if (faces.length === 0) return group([]);
+  const classes = Math.max(1, Math.floor(nClasses));
+  const rng = mulberry32(seed >>> 0);
+  const label = faces.map(() => Math.floor(rng() * classes));
+  const adj = faceAdjacency(faces);
+  const parent = faces.map((_, i) => i);
+  const find = (i) => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const unite = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  for (let i = 0; i < faces.length; i++) {
+    for (const j of adj[i]) {
+      if (j > i && label[i] === label[j]) unite(i, j);
+    }
+  }
+  const comps = /* @__PURE__ */ new Map();
+  for (let i = 0; i < faces.length; i++) {
+    const r = find(i);
+    const list = comps.get(r) ?? [];
+    list.push(i);
+    comps.set(r, list);
+  }
+  const out = [];
+  for (const members of comps.values()) {
+    if (members.length === 1) {
+      out.push(faces[members[0]]);
+      continue;
+    }
+    const merged = dissolveFaces(members.map((i) => faces[i]));
+    out.push(...merged);
+  }
+  return group(out);
+}
+function dissolveFaces(faces) {
+  if (faces.length === 0) return [];
+  if (faces.length === 1) return [faces[0]];
+  try {
+    let acc = faces[0];
+    for (let i = 1; i < faces.length; i++) {
+      const u = union(acc, faces[i]);
+      if (u.paths.length === 0) continue;
+      acc = u.paths.reduce(
+        (best, p) => area(p) > area(best) ? p : best
+      );
+    }
+    return [acc];
+  } catch {
+    return [convexHullOf(faces.flatMap((f) => ringOf(f)))];
+  }
+}
+function convexHullOf(points) {
+  const pts = unique(points);
+  if (pts.length < 3) return polygon(pts);
+  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+      lower.pop();
+    }
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return polygon([...lower, ...upper]);
+}
+function mulberry32(a) {
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
 
 // src/construction/index.ts
 function createCircle(cx, cy, radius, segments = 64) {
@@ -71,6 +453,50 @@ function createKochSnowflake(cx, cy, radius, iterations = 3) {
   }
   return polygon(ring);
 }
+function createSponge(width, height, generators, thickness, smoothing, classes, seed = 1) {
+  const w = Math.max(width, 1e-9);
+  const h = Math.max(height, 1e-9);
+  const nGen = Math.max(6, Math.floor(generators));
+  const nClasses = Math.max(1, Math.floor(classes));
+  const smoothIters = Math.max(0, Math.floor(smoothing));
+  const wall = Math.max(0, thickness);
+  const sites = randomInBox(nGen, 0, 0, w, h, seed);
+  const cells = compoundVoronoi(sites, {
+    bounds: { minX: 0, minY: 0, maxX: w, maxY: h }
+  });
+  const merged = stochasticMerge(cells.paths, nClasses, seed + 1);
+  const pores = [];
+  for (let p of merged.paths) {
+    if (smoothIters > 0) p = smooth(p, smoothIters);
+    if (wall > 1e-12) {
+      pores.push(...buffer(p, -wall * 0.5).paths);
+    } else {
+      pores.push(p);
+    }
+  }
+  const frame = createRect(0, 0, w, h);
+  if (pores.length === 0) return group([frame]);
+  return subtractAll(frame, pores);
+}
+function randomInBox(count, minX, minY, maxX, maxY, seed) {
+  const rng = mulberry322(seed >>> 0);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    out.push({
+      x: minX + rng() * (maxX - minX),
+      y: minY + rng() * (maxY - minY)
+    });
+  }
+  return out;
+}
+function mulberry322(a) {
+  return function() {
+    let t = a += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
 function kochRefine(ring) {
   const out = [];
   const n = ring.length;
@@ -94,9 +520,10 @@ var construction = {
   createRing,
   createArc,
   createStar,
-  createKochSnowflake
+  createKochSnowflake,
+  createSponge
 };
 
-export { construction, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createStar };
+export { construction, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createSponge, createStar };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map