@vibecook/ice 0.1.0 → 0.2.0

package/dist/{chunk-BCJ47SX7.js → chunk-OR5FNVUE.js}

@@ -36,6 +36,15 @@ function zoomAtPoint(camera, screenX, screenY, newZoom) {
     zoom: newZoom
   };
 }
+function fitCamera(content, vpW, vpH, opts) {
+  const fit = Math.min(vpW / (content.width + opts.pad * 2), vpH / (content.height + opts.pad * 2));
+  const zoom = Math.min(opts.maxZoom, Math.max(opts.minZoom, fit));
+  return {
+    x: content.x + content.width / 2 - vpW / (2 * zoom),
+    y: content.y + content.height / 2 - vpH / (2 * zoom),
+    zoom
+  };
+}
 function planeCssTransform(camera) {
   return {
     tx: -camera.x * camera.zoom,
@@ -488,6 +497,62 @@ function cubicAABB(c) {
     maxY: Math.max(c.y0, c.y1, c.y2, c.y3)
   };
 }
+function flatEnough(c, tolSq) {
+  const dx = c.x3 - c.x0;
+  const dy = c.y3 - c.y0;
+  const chordSq = dx * dx + dy * dy;
+  if (chordSq <= 1e-12) {
+    const d12 = Math.hypot(c.x1 - c.x0, c.y1 - c.y0);
+    const d22 = Math.hypot(c.x2 - c.x0, c.y2 - c.y0);
+    return (d12 + d22) * (d12 + d22) <= tolSq;
+  }
+  const d1 = Math.abs((c.x1 - c.x0) * dy - (c.y1 - c.y0) * dx);
+  const d2 = Math.abs((c.x2 - c.x0) * dy - (c.y2 - c.y0) * dx);
+  return (d1 + d2) * (d1 + d2) <= tolSq * chordSq;
+}
+function splitCubic(c) {
+  const ax = (c.x0 + c.x1) / 2;
+  const ay = (c.y0 + c.y1) / 2;
+  const bx = (c.x1 + c.x2) / 2;
+  const by = (c.y1 + c.y2) / 2;
+  const cx = (c.x2 + c.x3) / 2;
+  const cy = (c.y2 + c.y3) / 2;
+  const abx = (ax + bx) / 2;
+  const aby = (ay + by) / 2;
+  const bcx = (bx + cx) / 2;
+  const bcy = (by + cy) / 2;
+  const mx = (abx + bcx) / 2;
+  const my = (aby + bcy) / 2;
+  return [
+    { x0: c.x0, y0: c.y0, x1: ax, y1: ay, x2: abx, y2: aby, x3: mx, y3: my },
+    { x0: mx, y0: my, x1: bcx, y1: bcy, x2: cx, y2: cy, x3: c.x3, y3: c.y3 }
+  ];
+}
+function tessellateCubic(c, tolerance = 0.25, maxDepth = 16) {
+  const pts = [c.x0, c.y0];
+  const tolSq = tolerance * tolerance;
+  const walk = (cur, depth) => {
+    if (depth >= maxDepth || flatEnough(cur, tolSq)) {
+      pts.push(cur.x3, cur.y3);
+      return;
+    }
+    const [l, r] = splitCubic(cur);
+    walk(l, depth + 1);
+    walk(r, depth + 1);
+  };
+  walk(c, 0);
+  const n = pts.length / 2;
+  const points = new Float32Array(pts);
+  const arcLength = new Float32Array(n);
+  let acc = 0;
+  for (let i = 1; i < n; i++) {
+    const dx = pts[i * 2] - pts[i * 2 - 2];
+    const dy = pts[i * 2 + 1] - pts[i * 2 - 1];
+    acc += Math.hypot(dx, dy);
+    arcLength[i] = acc;
+  }
+  return { points, arcLength };
+}
 function distanceToSegment(px, py, ax, ay, bx, by) {
   const dx = bx - ax;
   const dy = by - ay;
@@ -513,6 +578,385 @@ function distanceToCubic(px, py, c, samples = 32) {
   return best;
 }
 
+// ../kernel/src/easing.ts
+function sample(u, p1, p2) {
+  const v = 1 - u;
+  return 3 * v * v * u * p1 + 3 * v * u * u * p2 + u * u * u;
+}
+function cubicBezierEase(x1, y1, x2, y2) {
+  const cx1 = Math.min(1, Math.max(0, x1));
+  const cx2 = Math.min(1, Math.max(0, x2));
+  const sampleDx = (u) => {
+    const v = 1 - u;
+    return 3 * v * v * cx1 + 6 * v * u * (cx2 - cx1) + 3 * u * u * (1 - cx2);
+  };
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    let u = t;
+    for (let i = 0; i < 8; i++) {
+      const err = sample(u, cx1, cx2) - t;
+      if (Math.abs(err) < 1e-6) return sample(u, y1, y2);
+      const d = sampleDx(u);
+      if (d < 1e-6) break;
+      u = Math.min(1, Math.max(0, u - err / d));
+    }
+    let lo = 0;
+    let hi = 1;
+    u = t;
+    while (hi - lo > 1e-6) {
+      if (sample(u, cx1, cx2) < t) lo = u;
+      else hi = u;
+      u = (lo + hi) / 2;
+    }
+    return sample(u, y1, y2);
+  };
+}
+
+// ../kernel/src/nav-flight.ts
+function visibleRect(cam, vpW, vpH) {
+  return { x: cam.x, y: cam.y, width: vpW / cam.zoom, height: vpH / cam.zoom };
+}
+function portalAffine(arrival, portal) {
+  const s = Math.min(portal.width / arrival.width, portal.height / arrival.height);
+  return {
+    s,
+    ox: portal.x + portal.width / 2 - (arrival.x + arrival.width / 2) * s,
+    oy: portal.y + portal.height / 2 - (arrival.y + arrival.height / 2) * s
+  };
+}
+function invertAffine(a) {
+  return { s: 1 / a.s, ox: -a.ox / a.s, oy: -a.oy / a.s };
+}
+function composeAffine(outer, inner) {
+  return { s: outer.s * inner.s, ox: outer.ox + inner.ox * outer.s, oy: outer.oy + inner.oy * outer.s };
+}
+function solveFlightStart(A, camPre) {
+  return {
+    x: A.ox + camPre.x * A.s,
+    y: A.oy + camPre.y * A.s,
+    zoom: camPre.zoom / A.s
+  };
+}
+function flightOctaves(from, to) {
+  return Math.abs(Math.log2(to.zoom / from.zoom));
+}
+function capFlightStart(exact, arrival, vpW, vpH, maxOctaves, capFactor) {
+  if (flightOctaves(exact, arrival) <= maxOctaves) return { c0: exact, capped: false };
+  const zCap = exact.zoom > arrival.zoom ? arrival.zoom * capFactor : arrival.zoom / capFactor;
+  return {
+    c0: {
+      x: exact.x + vpW / 2 * (1 / exact.zoom - 1 / zCap),
+      y: exact.y + vpH / 2 * (1 / exact.zoom - 1 / zCap),
+      zoom: zCap
+    },
+    capped: true
+  };
+}
+function flightCamera(c0, c1, p, vpW, vpH) {
+  const zoom = Math.exp(Math.log(c0.zoom) + (Math.log(c1.zoom) - Math.log(c0.zoom)) * p);
+  const inv0 = 1 / c0.zoom;
+  const inv1 = 1 / c1.zoom;
+  const inv = 1 / zoom;
+  const w = Math.abs(inv1 - inv0) < 1e-12 ? p : (inv - inv0) / (inv1 - inv0);
+  const cx = c0.x + vpW * inv0 * 0.5 + (c1.x + vpW * inv1 * 0.5 - (c0.x + vpW * inv0 * 0.5)) * w;
+  const cy = c0.y + vpH * inv0 * 0.5 + (c1.y + vpH * inv1 * 0.5 - (c0.y + vpH * inv0 * 0.5)) * w;
+  return { x: cx - vpW * inv * 0.5, y: cy - vpH * inv * 0.5, zoom };
+}
+function springStep(p, v, omega, dtSec) {
+  const u = 1 - p;
+  const B = -v + omega * u;
+  const decay = Math.exp(-omega * dtSec);
+  const u2 = (u + B * dtSec) * decay;
+  const du2 = (B - omega * (u + B * dtSec)) * decay;
+  return { p: 1 - u2, v: -du2 };
+}
+
+// ../kernel/src/layout.ts
+function crowds(a, b, gutter) {
+  return a.x < b.x + b.w + gutter && b.x < a.x + a.w + gutter && a.y < b.y + b.h + gutter && b.y < a.y + a.h + gutter;
+}
+function isFree(x, y, size, incumbents, gutter) {
+  const r = { x, y, w: size.w, h: size.h };
+  for (const i of incumbents) {
+    if (crowds(r, i, gutter)) return false;
+  }
+  return true;
+}
+function insertSlot(incumbents, size, hint, gutter) {
+  if (incumbents.length === 0 || isFree(hint.x, hint.y, size, incumbents, gutter)) {
+    return { x: hint.x, y: hint.y };
+  }
+  let best;
+  let bestD = Number.POSITIVE_INFINITY;
+  for (const i of incumbents) {
+    const candidates = [
+      { x: i.x + i.w + gutter, y: i.y },
+      // right, top-aligned
+      { x: i.x, y: i.y + i.h + gutter },
+      // below, left-aligned
+      { x: i.x - size.w - gutter, y: i.y },
+      // left, top-aligned
+      { x: i.x, y: i.y - size.h - gutter },
+      // above, left-aligned
+      { x: i.x + i.w + gutter, y: i.y + i.h - size.h },
+      // right, bottom-aligned
+      { x: i.x + i.w - size.w, y: i.y + i.h + gutter }
+      // below, right-aligned
+    ];
+    for (const c of candidates) {
+      if (!isFree(c.x, c.y, size, incumbents, gutter)) continue;
+      const d = (c.x - hint.x) ** 2 + (c.y - hint.y) ** 2;
+      if (d < bestD) {
+        bestD = d;
+        best = c;
+      }
+    }
+  }
+  if (best !== void 0) return best;
+  let maxRight = Number.NEGATIVE_INFINITY;
+  for (const i of incumbents) maxRight = Math.max(maxRight, i.x + i.w);
+  return { x: maxRight + gutter, y: hint.y };
+}
+function packLayout(items, opts) {
+  if (items.length === 0) return [];
+  const gutter = opts.gutter;
+  let ox;
+  let oy;
+  if (opts.origin !== void 0) {
+    ox = opts.origin.x;
+    oy = opts.origin.y;
+  } else {
+    ox = Number.POSITIVE_INFINITY;
+    oy = Number.POSITIVE_INFINITY;
+    for (const it of items) {
+      ox = Math.min(ox, it.x);
+      oy = Math.min(oy, it.y);
+    }
+  }
+  let maxWidth = opts.maxWidth;
+  if (maxWidth === void 0) {
+    let area = 0;
+    let widest = 0;
+    for (const it of items) {
+      area += (it.w + gutter) * (it.h + gutter);
+      widest = Math.max(widest, it.w);
+    }
+    maxWidth = Math.max(widest, Math.sqrt(area * 1.6));
+  }
+  const order = items.map((_, i) => i).sort((a, b) => {
+    const ia = items[a];
+    const ib = items[b];
+    return ia.y - ib.y || ia.x - ib.x || a - b;
+  });
+  const placed = [...opts.obstacles ?? []];
+  const out = new Array(items.length);
+  for (const idx of order) {
+    const it = items[idx];
+    const cands = [{ x: ox, y: oy }];
+    for (const r of placed) {
+      cands.push({ x: r.x + r.w + gutter, y: r.y });
+      cands.push({ x: r.x, y: r.y + r.h + gutter });
+      cands.push({ x: ox, y: r.y + r.h + gutter });
+    }
+    let best;
+    for (const inBand of [true, false]) {
+      for (const c of cands) {
+        if (c.x < ox || c.y < oy) continue;
+        if (inBand && c.x + it.w > ox + maxWidth) continue;
+        if (!isFree(c.x, c.y, it, placed, gutter)) continue;
+        if (best === void 0 || c.y < best.y || c.y === best.y && c.x < best.x) best = c;
+      }
+      if (best !== void 0) break;
+    }
+    if (best === void 0) {
+      let maxBottom = oy;
+      for (const r of placed) maxBottom = Math.max(maxBottom, r.y + r.h);
+      best = { x: ox, y: maxBottom + gutter };
+    }
+    out[idx] = { x: best.x, y: best.y };
+    placed.push({ x: best.x, y: best.y, w: it.w, h: it.h });
+  }
+  return out;
+}
+function layerGraph(nodes, edges, opts) {
+  const n = nodes.length;
+  if (n === 0) return [];
+  const outAdj = Array.from({ length: n }, () => []);
+  for (const [u, v] of edges) {
+    if (u !== v && u >= 0 && u < n && v >= 0 && v < n) outAdj[u]?.push(v);
+  }
+  const kept = [];
+  const state = new Array(n).fill(0);
+  for (let root = 0; root < n; root++) {
+    if (state[root] !== 0) continue;
+    const stack = [{ u: root, i: 0 }];
+    state[root] = 1;
+    while (stack.length > 0) {
+      const top = stack[stack.length - 1];
+      const adj = outAdj[top.u];
+      if (top.i < adj.length) {
+        const v = adj[top.i];
+        top.i += 1;
+        if (state[v] === 1) continue;
+        kept.push([top.u, v]);
+        if (state[v] === 0) {
+          state[v] = 1;
+          stack.push({ u: v, i: 0 });
+        }
+      } else {
+        state[top.u] = 2;
+        stack.pop();
+      }
+    }
+  }
+  const keptOut = Array.from({ length: n }, () => []);
+  const indeg = new Array(n).fill(0);
+  for (const [u, v] of kept) {
+    keptOut[u]?.push(v);
+    indeg[v] = indeg[v] + 1;
+  }
+  const rank = new Array(n).fill(0);
+  const queue = [];
+  for (let i = 0; i < n; i++) if (indeg[i] === 0) queue.push(i);
+  for (let qi = 0; qi < queue.length; qi++) {
+    const u = queue[qi];
+    for (const v of keptOut[u]) {
+      rank[v] = Math.max(rank[v], rank[u] + 1);
+      indeg[v] = indeg[v] - 1;
+      if (indeg[v] === 0) queue.push(v);
+    }
+  }
+  const maxRank = Math.max(...rank);
+  const layers = Array.from({ length: maxRank + 1 }, () => []);
+  for (let i = 0; i < n; i++) layers[rank[i]]?.push(i);
+  const neighbors = Array.from({ length: n }, () => []);
+  for (const [u, v] of kept) {
+    neighbors[u]?.push(v);
+    neighbors[v]?.push(u);
+  }
+  const slot = new Array(n).fill(0);
+  const reSlot = () => {
+    for (const layer of layers) {
+      layer.forEach((node, s) => {
+        slot[node] = s;
+      });
+    }
+  };
+  reSlot();
+  const crossings = () => {
+    let total = 0;
+    for (let li = 0; li < maxRank; li++) {
+      const pairs = [];
+      for (const [u, v] of kept) {
+        if (rank[u] === li && rank[v] === li + 1) pairs.push([slot[u], slot[v]]);
+      }
+      for (let i = 0; i < pairs.length; i++) {
+        for (let j = i + 1; j < pairs.length; j++) {
+          const a = pairs[i];
+          const b = pairs[j];
+          if ((a[0] - b[0]) * (a[1] - b[1]) < 0) total += 1;
+        }
+      }
+    }
+    return total;
+  };
+  const snapshot = () => layers.map((l) => [...l]);
+  const restore = (saved) => {
+    saved.forEach((l, li) => {
+      layers[li] = [...l];
+    });
+    reSlot();
+  };
+  let best = snapshot();
+  let bestX = crossings();
+  for (let sweep = 0; sweep < 4 && bestX > 0; sweep++) {
+    const forward = sweep % 2 === 0;
+    for (let li = forward ? 1 : maxRank - 1; forward ? li <= maxRank : li >= 0; li += forward ? 1 : -1) {
+      const layer = layers[li];
+      const bary = (node) => {
+        const ns = neighbors[node].filter((m) => Math.abs(rank[m] - li) === 1);
+        if (ns.length === 0) return slot[node];
+        return ns.reduce((sum, m) => sum + slot[m], 0) / ns.length;
+      };
+      layer.sort((a, b) => bary(a) - bary(b) || a - b);
+      reSlot();
+    }
+    const x = crossings();
+    if (x < bestX) {
+      bestX = x;
+      best = snapshot();
+    }
+  }
+  restore(best);
+  let improved = bestX > 0;
+  for (let round = 0; round < 4 && improved; round++) {
+    improved = false;
+    for (const layer of layers) {
+      for (let s = 0; s + 1 < layer.length; s++) {
+        const a = layer[s];
+        const b = layer[s + 1];
+        layer[s] = b;
+        layer[s + 1] = a;
+        reSlot();
+        const x = crossings();
+        if (x < bestX) {
+          bestX = x;
+          improved = true;
+        } else {
+          layer[s] = a;
+          layer[s + 1] = b;
+          reSlot();
+        }
+      }
+    }
+  }
+  const colW = layers.map((layer) => {
+    let widest = 0;
+    for (const node of layer) widest = Math.max(widest, nodes[node].w);
+    return widest;
+  });
+  const colH = layers.map(
+    (layer) => layer.reduce((sum, node, i) => sum + nodes[node].h + (i > 0 ? opts.gapY : 0), 0)
+  );
+  const bands = [];
+  if (opts.maxWidth === void 0) {
+    bands.push(layers.map((_, li) => li));
+  } else {
+    let cur = [];
+    let width = 0;
+    for (let li = 0; li <= maxRank; li++) {
+      const grown = (cur.length > 0 ? width + opts.gapX : 0) + colW[li];
+      if (cur.length > 0 && grown > opts.maxWidth) {
+        bands.push(cur);
+        cur = [li];
+        width = colW[li];
+      } else {
+        cur.push(li);
+        width = grown;
+      }
+    }
+    if (cur.length > 0) bands.push(cur);
+  }
+  const out = new Array(n);
+  let bandTop = 0;
+  for (const band of bands) {
+    let tallest = 0;
+    for (const li of band) tallest = Math.max(tallest, colH[li]);
+    let x = 0;
+    for (const li of band) {
+      let y = bandTop + (tallest - colH[li]) / 2;
+      for (const node of layers[li]) {
+        out[node] = { x, y };
+        y += nodes[node].h + opts.gapY;
+      }
+      x += colW[li] + opts.gapX;
+    }
+    bandTop += tallest + opts.gapY * 2;
+  }
+  return out;
+}
+
 // ../kernel/src/index.ts
 var KERNEL_VERSION = "0.0.0";
 
@@ -525,6 +969,7 @@ export {
   screenToWorld,
   worldToScreen,
   zoomAtPoint,
+  fitCamera,
   planeCssTransform,
   worldToIsland,
   islandToWorld,
@@ -543,8 +988,22 @@ export {
   wireCubic,
   cubicPoint,
   cubicAABB,
+  tessellateCubic,
   distanceToSegment,
   distanceToCubic,
+  cubicBezierEase,
+  visibleRect,
+  portalAffine,
+  invertAffine,
+  composeAffine,
+  solveFlightStart,
+  flightOctaves,
+  capFlightStart,
+  flightCamera,
+  springStep,
+  insertSlot,
+  packLayout,
+  layerGraph,
   KERNEL_VERSION
 };
-//# sourceMappingURL=chunk-BCJ47SX7.js.map
+//# sourceMappingURL=chunk-OR5FNVUE.js.map