@weasel-js/core 1.9.4 → 1.10.0

package/dist/features/minimap/layers.js

@@ -1,85 +0,0 @@
-import { computeIndicatorCommand as e } from "../../canvas/minimapMath.js";
-//#region src/features/minimap/layers.ts
-function t(e) {
-	return e?.viewId ?? null;
-}
-function n(n) {
-	let { viewId: r, root: i, style: a = {} } = n;
-	return {
-		id: `${r}.indicator`,
-		label: "Minimap indicator",
-		draw: (n, o) => {
-			if (t(n) !== r) return [];
-			let s = i(), c = s?.hostSize?.();
-			return !s || !c ? [] : [e(s.get(), c, a, o)];
-		}
-	};
-}
-var r = 9, i = 3, a = 2, o = 1, s = "rgba(0, 0, 0, 0.6)";
-function c(e, t, n) {
-	let s = n, c = r * s, l = i * s, u = a * s, d = o * s, f = [
-		{
-			x: e - l - c,
-			y: t - u / 2,
-			w: c,
-			h: u
-		},
-		{
-			x: e + l,
-			y: t - u / 2,
-			w: c,
-			h: u
-		},
-		{
-			x: e - u / 2,
-			y: t - l - c,
-			w: u,
-			h: c
-		},
-		{
-			x: e - u / 2,
-			y: t + l,
-			w: u,
-			h: c
-		}
-	];
-	return {
-		halo: f.map((e) => ({
-			x: e.x - d,
-			y: e.y - d,
-			w: e.w + 2 * d,
-			h: e.h + 2 * d
-		})),
-		bars: f
-	};
-}
-function l(e) {
-	let { id: n, pointer: r, color: i, views: a } = e;
-	return {
-		id: n,
-		label: "Linked cursor",
-		draw: (e, n) => {
-			let o = r(), l = t(e);
-			if (!o || o.viewId === l || a && !a.includes(l)) return [];
-			let { halo: u, bars: d } = c(o.worldX, o.worldY, 1 / n.scale.x), f = (e, t) => ({
-				kind: "path",
-				path: {
-					kind: "rect",
-					x: e.x,
-					y: e.y,
-					width: e.w,
-					height: e.h
-				},
-				fill: {
-					fill: "solid",
-					color: t
-				}
-			}), p = i();
-			return [...u.map((e) => f(e, s)), ...d.map((e) => f(e, p))];
-		}
-	};
-}
-//#endregion
-export { s as CROSSHAIR_HALO, n as createIndicatorLayer, l as createLinkedCursorLayer, c as crosshairRects };
-
-//# sourceMappingURL=layers.js.map

package/dist/features/minimap/layers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"layers.js","names":["viewIdOf","data","createIndicatorLayer","opts","viewId","r","root","size","computeIndicatorCommand","style","view","ARM","GAP","THICK","HALO","CROSSHAIR_HALO","crosshairRects","k","unitsPerPx","arm","gap","t","h","bars","x","y","b","createLinkedCursorLayer","p","pointer","here","views","rect","c","accent","color","halo"],"sources":["../../../src/features/minimap/layers.ts"],"sourcesContent":["/**\n * The minimap's chrome: the main camera's visible rect, drawn in the minimap,\n * and the linked crosshair, drawn in every view the pointer is not over.\n */\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { DrawCommand } from '../../renderer/DrawCommand';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport type { PointerWorldPos } from 'features/pointer/PointerContext';\nimport { computeIndicatorCommand, type IndicatorStyle } from '../../canvas/minimapMath';\n\n/** What a layer's `data` carries for this feature: the view it draws for. */\nfunction viewIdOf(data: unknown): string | null {\n  return (data as { viewId?: string | null } | null)?.viewId ?? null;\n}\n\n/**\n * The main camera's visible world rect, painted only in view `viewId`. Its\n * stroke and dash are screen pixels whatever the minimap's scale.\n */\nexport function createIndicatorLayer(opts: {\n  viewId: string;\n  root: () => ViewApi | undefined;\n  style?: IndicatorStyle;\n}): RenderLayer<unknown> {\n  const { viewId, root, style = {} } = opts;\n  return {\n    id: `${viewId}.indicator`,\n    label: 'Minimap indicator',\n    draw: (data, view: View): DrawCommand[] => {\n      if (viewIdOf(data) !== viewId) return [];\n      const r = root();\n      const size = r?.hostSize?.();\n      if (!r || !size) return [];\n      return [computeIndicatorCommand(r.get(), size, style, view)];\n    },\n  };\n}\n\n/** Screen-pixel geometry of the crosshair: arm length, the gap at its center,\n *  line thickness, and the dark halo that keeps it legible over any content. */\nconst ARM = 9;\nconst GAP = 3;\nconst THICK = 2;\nconst HALO = 1;\n/** The halo's color: dark enough to separate the accent from any content. */\nexport const CROSSHAIR_HALO = 'rgba(0, 0, 0, 0.6)';\n\n/** An axis-aligned rect, `{ x, y, w, h }`. */\nexport interface CrosshairRect { x: number; y: number; w: number; h: number }\n\n/**\n * The linked crosshair at (`x`, `y`) as rects in the caller's units, where one\n * screen pixel is `unitsPerPx` of them: four halo rects to paint first, then\n * four bars. A painter with no weasel renderer — a 2D canvas — draws the same\n * crosshair from these.\n */\nexport function crosshairRects(\n  x: number, y: number, unitsPerPx: number,\n): { halo: CrosshairRect[]; bars: CrosshairRect[] } {\n  const k = unitsPerPx;\n  const arm = ARM * k, gap = GAP * k, t = THICK * k, h = HALO * k;\n  const bars: CrosshairRect[] = [\n    { x: x - gap - arm, y: y - t / 2, w: arm, h: t },\n    { x: x + gap, y: y - t / 2, w: arm, h: t },\n    { x: x - t / 2, y: y - gap - arm, w: t, h: arm },\n    { x: x - t / 2, y: y + gap, w: t, h: arm },\n  ];\n  const halo = bars.map((b) => ({ x: b.x - h, y: b.y - h, w: b.w + 2 * h, h: b.h + 2 * h }));\n  return { halo, bars };\n}\n\n/**\n * A crosshair at the pointer's world point, in each of `views` the pointer is\n * not over — the other side of a linked cursor. A fixed screen size in every\n * view. `views` omitted paints in every view.\n */\nexport function createLinkedCursorLayer(opts: {\n  id: string;\n  pointer: () => PointerWorldPos;\n  color: () => string;\n  views?: readonly (string | null)[];\n}): RenderLayer<unknown> {\n  const { id, pointer, color, views } = opts;\n  return {\n    id,\n    label: 'Linked cursor',\n    draw: (data, view: View): DrawCommand[] => {\n      const p = pointer();\n      const here = viewIdOf(data);\n      if (!p || p.viewId === here || (views && !views.includes(here))) return [];\n      const { halo, bars } = crosshairRects(p.worldX, p.worldY, 1 / view.scale.x);\n      const rect = (r: CrosshairRect, c: string): DrawCommand => ({\n        kind: 'path',\n        path: { kind: 'rect', x: r.x, y: r.y, width: r.w, height: r.h },\n        fill: { fill: 'solid', color: c },\n      });\n      const accent = color();\n      return [\n        ...halo.map((r) => rect(r, CROSSHAIR_HALO)),\n        ...bars.map((r) => rect(r, accent)),\n      ];\n    },\n  };\n}\n"],"mappings":";;AAYA,SAASA,EAAS,GAA8B;CAC9C,OAAQC,GAA4C,UAAU;AAChE;AAMA,SAAgBC,EAAqB,GAIZ;CACvB,IAAM,EAAE,WAAQ,SAAM,WAAQ,CAAC,MAAMC;CACrC,OAAO;EACL,IAAI,GAAGC,EAAO;EACd,OAAO;EACP,OAAO,GAAM,MAA8B;GACzC,IAAIJ,EAASC,CAAI,MAAMG,GAAQ,OAAO,CAAC;GACvC,IAAMC,IAAIC,EAAK,GACTC,IAAOF,GAAG,WAAW;GAE3B,OADI,CAACA,KAAK,CAACE,IAAa,CAAC,IAClB,CAACC,EAAwBH,EAAE,IAAI,GAAGE,GAAME,GAAOC,CAAI,CAAC;EAC7D;CACF;AACF;AAIA,IAAMC,IAAM,GACNC,IAAM,GACNC,IAAQ,GACRC,IAAO,GAEAC,IAAiB;AAW9B,SAAgBC,EACd,GAAW,GAAW,GAC4B;CAClD,IAAMC,IAAIC,GACJC,IAAMR,IAAMM,GAAGG,IAAMR,IAAMK,GAAGI,IAAIR,IAAQI,GAAGK,IAAIR,IAAOG,GACxDM,IAAwB;EAC5B;GAAE,GAAGC,IAAIJ,IAAMD;GAAK,GAAGM,IAAIJ,IAAI;GAAG,GAAGF;GAAK,GAAGE;EAAE;EAC/C;GAAE,GAAGG,IAAIJ;GAAK,GAAGK,IAAIJ,IAAI;GAAG,GAAGF;GAAK,GAAGE;EAAE;EACzC;GAAE,GAAGG,IAAIH,IAAI;GAAG,GAAGI,IAAIL,IAAMD;GAAK,GAAGE;GAAG,GAAGF;EAAI;EAC/C;GAAE,GAAGK,IAAIH,IAAI;GAAG,GAAGI,IAAIL;GAAK,GAAGC;GAAG,GAAGF;EAAI;CAC3C;CAEA,OAAO;EAAE,MADII,EAAK,KAAK,OAAO;GAAE,GAAGG,EAAE,IAAIJ;GAAG,GAAGI,EAAE,IAAIJ;GAAG,GAAGI,EAAE,IAAI,IAAIJ;GAAG,GAAGI,EAAE,IAAI,IAAIJ;EAAE,EAC9E;EAAM;CAAK;AACtB;AAOA,SAAgBK,EAAwB,GAKf;CACvB,IAAM,EAAE,OAAI,YAAS,UAAO,aAAUxB;CACtC,OAAO;EACL;EACA,OAAO;EACP,OAAO,GAAM,MAA8B;GACzC,IAAMyB,IAAIC,EAAQ,GACZC,IAAO9B,EAASC,CAAI;GAC1B,IAAI,CAAC2B,KAAKA,EAAE,WAAWE,KAASC,KAAS,CAACA,EAAM,SAASD,CAAI,GAAI,OAAO,CAAC;GACzE,IAAM,EAAE,SAAM,YAASd,EAAeY,EAAE,QAAQA,EAAE,QAAQ,IAAIlB,EAAK,MAAM,CAAC,GACpEsB,KAAQ,GAAkB,OAA4B;IAC1D,MAAM;IACN,MAAM;KAAE,MAAM;KAAQ,GAAG3B,EAAE;KAAG,GAAGA,EAAE;KAAG,OAAOA,EAAE;KAAG,QAAQA,EAAE;IAAE;IAC9D,MAAM;KAAE,MAAM;KAAS,OAAO4B;IAAE;GAClC,IACMC,IAASC,EAAM;GACrB,OAAO,CACL,GAAGC,EAAK,KAAK,MAAMJ,EAAK3B,GAAGU,CAAc,CAAC,GAC1C,GAAGQ,EAAK,KAAK,MAAMS,EAAK3B,GAAG6B,CAAM,CAAC,CACpC;EACF;CACF;AACF"}

package/dist/features/overlays/useNodeOverlayFrame.js

@@ -1,103 +0,0 @@
-import { useCanvasSize as e } from "../../core/viewport/useCanvasSize.js";
-import { composeWorldPose as t } from "../../core/scene/composeFrame.js";
-import { composeRectPose as n } from "../groups/composePose.js";
-import { effectivePose as r } from "../../core/scene/effectivePose.js";
-import { poseRotationOf as i } from "../../core/geometry/poseRotation.js";
-import { applyToPoint as a, invert as o, multiply as s } from "@weasel-js/geom";
-import { useCallback as c, useInsertionEffect as l, useRef as u } from "react";
-//#region src/features/overlays/useNodeOverlayFrame.ts
-function d(t, n, r, i = {}) {
-	let { width: d, height: g } = e(n), { view: _, compose: v } = i, y = c(() => {
-		let e = p(t, r, v);
-		return e ? s(m(f(_)), h(e)) : null;
-	}, [
-		t,
-		r,
-		v,
-		_
-	]), b = c((e) => {
-		let t = y();
-		if (!t) return e;
-		let [n, r] = a(t, e.x, e.y);
-		return {
-			x: n,
-			y: r
-		};
-	}, [y]), x = u(null), S = c((e) => {
-		let t = y(), n = t && o(t);
-		n && (x.current = n);
-		let [r, i] = a(n ?? x.current, e.x, e.y);
-		return {
-			x: r,
-			y: i
-		};
-	}, [y]), C = p(t, r, v), w = C && d !== 0 && g !== 0 ? y() : null, T = w && o(w);
-	return l(() => {
-		T && (x.current = T);
-	}), !C || !T ? null : {
-		box: {
-			x: C.x,
-			y: C.y,
-			width: C.width,
-			height: C.height
-		},
-		toScreen: b,
-		toLocal: S,
-		width: d,
-		height: g
-	};
-}
-function f(e) {
-	return typeof e == "function" ? e() : e;
-}
-function p(e, i, a) {
-	if (i == null) return null;
-	let o = e.nodes;
-	return o.has(i) ? t({
-		getPose: (t) => r(e, o.get(t)),
-		getParent: (e) => o.get(e)?.parent ?? null
-	}, i, a ?? n) : null;
-}
-function m(e) {
-	if (!e) return [
-		1,
-		0,
-		0,
-		1,
-		0,
-		0
-	];
-	let { x: t, y: n } = e.scale;
-	return [
-		t,
-		0,
-		0,
-		n,
-		-e.x * t,
-		-e.y * n
-	];
-}
-function h(e) {
-	let t = i(e);
-	if (!t) return [
-		1,
-		0,
-		0,
-		1,
-		0,
-		0
-	];
-	let n = Math.cos(t.rotation), r = Math.sin(t.rotation);
-	return [
-		n,
-		r,
-		-r,
-		n,
-		t.cx - t.cx * n + t.cy * r,
-		t.cy - t.cx * r - t.cy * n
-	];
-}
-//#endregion
-export { d as useNodeOverlayFrame };
-
-//# sourceMappingURL=useNodeOverlayFrame.js.map

package/dist/features/overlays/useNodeOverlayFrame.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useNodeOverlayFrame.js","names":["useNodeOverlayFrame","useCanvasSize","containerRef","options","project","useCallback","box","worldBoxOf","scene","nodeId","compose","multiply","viewMatrix","resolveView","view","rotationMatrix","toScreen","m","p","x","y","applyToPoint","lastInverse","useRef","toLocal","inverse","invert","width","height","useInsertionEffect","nodes","composeWorldPose","effectivePose","id","composeRectPose","sx","sy","r","poseRotationOf","pose","c","s"],"sources":["../../../src/features/overlays/useNodeOverlayFrame.ts"],"sourcesContent":["/**\n * `useNodeOverlayFrame` — the coordinate frame a DOM overlay pinned to one\n * scene node needs: the node's world box, the projection from that box's\n * frame into overlay pixels, and the overlay's measured size.\n *\n * This is the frame half of `subscribeView`'s \"DOM pinned to world\n * coordinates\" case. Consumers positioning chrome over a node — gradient\n * handles, a badge, a caret — otherwise re-derive it, and the\n * translate-and-scale inverse that derivation usually reaches for drops\n * `pose.rotation`, so the chrome sits where the node would be unrotated.\n *\n * `toScreen` maps the node's **unrotated world box** frame, which is the\n * frame `fillInPoseFrame` resolves a `units: 'bounds'` paint into and the\n * one `pathInPoseFrame` projects geometry into. Rotation lives in this hook,\n * not in those: a node's stored geometry is pre-rotation by definition.\n */\nimport { useCallback, useInsertionEffect, useRef, type RefObject } from 'react';\nimport { applyToPoint, invert, multiply, type Mat3 } from '@weasel-js/geom';\nimport type { Node, RectPose, Scene } from '../../core/scene/types';\nimport { useCanvasSize } from '../../core/viewport/useCanvasSize';\nimport type { View } from '../../core/viewport/view';\nimport { composeRectPose, composeWorldPose } from '../groups/composePose';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\n\n/** Structural point, matching every other `{ x, y }` the kit passes across a\n *  boundary. */\nexport interface OverlayPoint {\n  x: number;\n  y: number;\n}\n\n/** The overlay frame for one node. `null` from the hook means there is no\n *  frame yet — no node, or nothing measured to draw it on. */\nexport interface NodeOverlayFrame {\n  /** The node's composed world box, **unrotated**: the frame `toScreen` maps\n   *  from, and the box to hand `fillInPoseFrame` / `fillToBoundsFrame`. */\n  box: { x: number; y: number; width: number; height: number };\n  /** Node box frame → overlay pixels, rotation and view included. */\n  toScreen: (p: OverlayPoint) => OverlayPoint;\n  /** Overlay pixels → node box frame. Inverts `toScreen`; while a live view\n   *  flattens an axis, it keeps the last mapping that had an inverse. */\n  toLocal: (p: OverlayPoint) => OverlayPoint;\n  /** The container's size in CSS pixels — the overlay's own box. */\n  width: number;\n  height: number;\n}\n\n/** Options for `useNodeOverlayFrame`. */\nexport interface UseNodeOverlayFrameOptions<TPose> {\n  /**\n   * Current viewport. A thunk is re-read on every projection, which is what\n   * an uncontrolled `SceneCanvas` needs — its camera lives in a ref and moves\n   * without a render, so pass the handle's `getView`. A plain `View` is the\n   * value from the render that supplied it, correct for a controlled\n   * consumer. Omit it and world units are handed through as screen pixels.\n   */\n  view?: View | (() => View);\n  /** Fold a child pose into its parent's frame. Default `composeRectPose`. */\n  compose?: (parent: TPose, child: TPose) => TPose;\n}\n\n/**\n * Resolve the overlay frame for `nodeId` against `containerRef` — the element\n * the overlay is positioned in, which must be the canvas's own box for the\n * projection to land.\n *\n * Returns `null` when there is no node under `nodeId`, when the container has\n * not been measured, or when the view collapses an axis to zero — the three\n * states in which an overlay has nothing to draw.\n */\nexport function useNodeOverlayFrame<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  containerRef: RefObject<HTMLElement | null>,\n  nodeId: string | null | undefined,\n  options: UseNodeOverlayFrameOptions<TPose> = {},\n): NodeOverlayFrame | null {\n  const { width, height } = useCanvasSize(containerRef);\n  const { view, compose } = options;\n\n  const project = useCallback((): Mat3 | null => {\n    const box = worldBoxOf(scene, nodeId, compose);\n    if (!box) return null;\n    return multiply(viewMatrix(resolveView(view)), rotationMatrix(box));\n  }, [scene, nodeId, compose, view]);\n\n  const toScreen = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    if (!m) return p;\n    const [x, y] = applyToPoint(m, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const lastInverse = useRef<Mat3 | null>(null);\n\n  const toLocal = useCallback((p: OverlayPoint): OverlayPoint => {\n    const m = project();\n    const inverse = m && invert(m);\n    if (inverse) lastInverse.current = inverse;\n    // Published by the commit that handed this toLocal out, so there is one.\n    const [x, y] = applyToPoint(inverse ?? lastInverse.current!, p.x, p.y);\n    return { x, y };\n  }, [project]);\n\n  const box = worldBoxOf(scene, nodeId, compose);\n  const m = box && width !== 0 && height !== 0 ? project() : null;\n  const inverse = m && invert(m);\n  useInsertionEffect(() => {\n    if (inverse) lastInverse.current = inverse;\n  });\n\n  if (!box || !inverse) return null;\n  return { box: { x: box.x, y: box.y, width: box.width, height: box.height }, toScreen, toLocal, width, height };\n}\n\nfunction resolveView(view: View | (() => View) | undefined): View | undefined {\n  return typeof view === 'function' ? view() : view;\n}\n\nfunction worldBoxOf<TData, TLayer extends string, TPose extends RectPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  nodeId: string | null | undefined,\n  compose: ((parent: TPose, child: TPose) => TPose) | undefined,\n): TPose | null {\n  if (nodeId == null) return null;\n  const nodes = scene.nodes as ReadonlyMap<string, Node<TData, TLayer, TPose>>;\n  if (!nodes.has(nodeId)) return null;\n  // `effectivePose`, not `node.pose`: an overlay tracks what the renderer\n  // draws, and a gesture override or a derived pose is exactly the difference.\n  const adapter = {\n    getPose: (id: string) => effectivePose(scene, nodes.get(id)!),\n    getParent: (id: string) => nodes.get(id)?.parent ?? null,\n  };\n  return composeWorldPose(adapter, nodeId, compose ?? composeRectPose);\n}\n\n/** World → overlay pixels: `screen = (world − view) × view.scale`. */\nfunction viewMatrix(view: View | undefined): Mat3 {\n  if (!view) return [1, 0, 0, 1, 0, 0];\n  const { x: sx, y: sy } = view.scale;\n  return [sx, 0, 0, sy, -view.x * sx, -view.y * sy];\n}\n\n/** The pose→world leg the box frame omits, per `poseRotationOf`'s convention. */\nfunction rotationMatrix(pose: RectPose): Mat3 {\n  const r = poseRotationOf(pose);\n  if (!r) return [1, 0, 0, 1, 0, 0];\n  const c = Math.cos(r.rotation);\n  const s = Math.sin(r.rotation);\n  return [c, s, -s, c, r.cx - r.cx * c + r.cy * s, r.cy - r.cx * s - r.cy * c];\n}\n"],"mappings":";;;;;;;;AAuEA,SAAgBA,EACd,GACA,GACA,GACA,IAA6C,CAAC,GACrB;CACzB,IAAM,EAAE,UAAO,cAAWC,EAAcC,CAAY,GAC9C,EAAE,SAAM,eAAYC,GAEpBC,IAAUC,QAA+B;EAC7C,IAAMC,IAAMC,EAAWC,GAAOC,GAAQC,CAAO;EAE7C,OADKJ,IACEK,EAASC,EAAWC,EAAYC,CAAI,CAAC,GAAGC,EAAeT,CAAG,CAAC,IADjD;CAEnB,GAAG;EAACE;EAAOC;EAAQC;EAASI;CAAI,CAAC,GAE3BE,IAAWX,GAAa,MAAkC;EAC9D,IAAMY,IAAIb,EAAQ;EAClB,IAAI,CAACa,GAAG,OAAOC;EACf,IAAM,CAACC,GAAGC,KAAKC,EAAaJ,GAAGC,EAAE,GAAGA,EAAE,CAAC;EACvC,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAACd,CAAO,CAAC,GAENkB,IAAcC,EAAoB,IAAI,GAEtCC,IAAUnB,GAAa,MAAkC;EAC7D,IAAMY,IAAIb,EAAQ,GACZqB,IAAUR,KAAKS,EAAOT,CAAC;EAC7B,AAAIQ,MAAS,EAAY,UAAUA;EAEnC,IAAM,CAACN,GAAGC,KAAKC,EAAaI,KAAWH,EAAY,SAAUJ,EAAE,GAAGA,EAAE,CAAC;EACrE,OAAO;GAAE;GAAG;EAAE;CAChB,GAAG,CAACd,CAAO,CAAC,GAENE,IAAMC,EAAWC,GAAOC,GAAQC,CAAO,GACvCO,IAAIX,KAAOqB,MAAU,KAAKC,MAAW,IAAIxB,EAAQ,IAAI,MACrDqB,IAAUR,KAAKS,EAAOT,CAAC;CAM7B,OALAY,QAAyB;EACvB,AAAIJ,MAAS,EAAY,UAAUA;CACrC,CAAC,GAEG,CAACnB,KAAO,CAACmB,IAAgB,OACtB;EAAE,KAAK;GAAE,GAAGnB,EAAI;GAAG,GAAGA,EAAI;GAAG,OAAOA,EAAI;GAAO,QAAQA,EAAI;EAAO;EAAG;EAAU;EAAS;EAAO;CAAO;AAC/G;AAEA,SAASO,EAAY,GAAyD;CAC5E,OAAO,OAAOC,KAAS,aAAaA,EAAK,IAAIA;AAC/C;AAEA,SAASP,EACP,GACA,GACA,GACc;CACd,IAAIE,KAAU,MAAM,OAAO;CAC3B,IAAMqB,IAAQtB,EAAM;CAQpB,OAPKsB,EAAM,IAAIrB,CAAM,IAOdsB,EAAiB;EAHtB,UAAU,MAAeC,EAAcxB,GAAOsB,EAAM,IAAIG,CAAE,CAAE;EAC5D,YAAY,MAAeH,EAAM,IAAIG,CAAE,CAAC,EAAE,UAAU;CAE9B,GAASxB,GAAQC,KAAWwB,CAAe,IAPpC;AAQjC;AAGA,SAAStB,EAAW,GAA8B;CAChD,IAAI,CAACE,GAAM,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CACnC,IAAM,EAAE,GAAGqB,GAAI,GAAGC,MAAOtB,EAAK;CAC9B,OAAO;EAACqB;EAAI;EAAG;EAAGC;EAAI,CAACtB,EAAK,IAAIqB;EAAI,CAACrB,EAAK,IAAIsB;CAAE;AAClD;AAGA,SAASrB,EAAe,GAAsB;CAC5C,IAAMsB,IAAIC,EAAeC,CAAI;CAC7B,IAAI,CAACF,GAAG,OAAO;EAAC;EAAG;EAAG;EAAG;EAAG;EAAG;CAAC;CAChC,IAAMG,IAAI,KAAK,IAAIH,EAAE,QAAQ,GACvBI,IAAI,KAAK,IAAIJ,EAAE,QAAQ;CAC7B,OAAO;EAACG;EAAGC;EAAG,CAACA;EAAGD;EAAGH,EAAE,KAAKA,EAAE,KAAKG,IAAIH,EAAE,KAAKI;EAAGJ,EAAE,KAAKA,EAAE,KAAKI,IAAIJ,EAAE,KAAKG;CAAC;AAC7E"}

package/dist/features/parallax/createParallaxLayer.js

@@ -1,26 +0,0 @@
-import { drawOneLayer as e, subscribeToSources as t } from "../../core/layers/render.js";
-import { deriveParallaxView as n } from "../../core/viewport/parallax.js";
-import { isParallaxSource as r } from "./createParallaxPlane.js";
-//#region src/features/parallax/createParallaxLayer.ts
-function i(i) {
-	let { id: a, label: o, source: s, parallax: c, getOuterView: l } = i, u = r(c) ? () => c.get() : () => c, d = t(s);
-	return {
-		id: a,
-		label: o,
-		space: "screen",
-		subscribe: r(c) ? (e) => {
-			let t = d(e), n = c.subscribe(e);
-			return () => {
-				t(), n();
-			};
-		} : d,
-		draw: (t, r, i) => {
-			let a = n(l?.() ?? r, u());
-			return s.flatMap((n) => e(n, t, a, i));
-		}
-	};
-}
-//#endregion
-export { i as createParallaxLayer };
-
-//# sourceMappingURL=createParallaxLayer.js.map

package/dist/features/parallax/createParallaxLayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createParallaxLayer.js","names":["createParallaxLayer","opts","read","isParallaxSource","parallax","fromSources","subscribeToSources","source","offSources","listener","offPlane","inner","deriveParallaxView","getOuterView","outer","drawOneLayer","layer","data","dims"],"sources":["../../../src/features/parallax/createParallaxLayer.ts"],"sourcesContent":["import { drawOneLayer, subscribeToSources, type RenderLayer } from '../../core/layers/render';\nimport type { View } from '../../core/viewport/view';\nimport { deriveParallaxView, type ParallaxOpts } from '../../core/viewport/parallax';\nimport { isParallaxSource, type ParallaxSource } from './createParallaxPlane';\n\n/** Options for `createParallaxLayer`. */\nexport interface CreateParallaxLayerOpts<TData> {\n  id: string;\n  label: string;\n  /** Layers re-rendered through the derived inner view. */\n  source: RenderLayer<TData>[];\n  /** How the plane tracks the camera. Pass a `ParallaxSource` (such as\n   *  `createParallaxPlane`) to change it after the layer is built — an\n   *  animator tweening `pan` or `zoom` writes the plane, not the layer. */\n  parallax: ParallaxOpts | ParallaxSource;\n  /** Where the camera view comes from. Defaults to the view the Canvas hands\n   *  the layer — the `view` prop. A consumer running a 60 Hz camera through\n   *  refs pins that prop to identity, and would otherwise get identity back\n   *  for every `pan` value and a backdrop that never moves. */\n  getOuterView?: () => View;\n}\n\n/**\n * Wrap source RenderLayers in a parallax plane. The plane's inner view is\n * derived from the camera view per {@link deriveParallaxView}; each source\n * layer is drawn through it by `drawOneLayer`, so a `space: 'world'` source\n * gets the inner view's transform and a `space: 'screen'` one does not. The\n * plane itself is emitted as `space: 'screen'` — its children already carry\n * whatever transform they need, and the outer Canvas must add none.\n *\n * What this draws is paint: pointer events target the camera's view. Content\n * that should be clickable belongs on a scene layer carrying `parallax`\n * instead, which `<SceneCanvas>` renders and picks through the same view.\n *\n * **Screen-space source layers don't compose meaningfully** — they ignore\n * the derived view by definition. Same constraint as `createViewportLayer`.\n */\nexport function createParallaxLayer<TData>(\n  opts: CreateParallaxLayerOpts<TData>,\n): RenderLayer<TData> {\n  const { id, label, source, parallax, getOuterView } = opts;\n  const read = isParallaxSource(parallax) ? () => parallax.get() : () => parallax;\n  const fromSources = subscribeToSources(source);\n  return {\n    id,\n    label,\n    space: 'screen',\n    subscribe: isParallaxSource(parallax)\n      ? (listener) => {\n        const offSources = fromSources(listener);\n        const offPlane = parallax.subscribe(listener);\n        return () => { offSources(); offPlane(); };\n      }\n      : fromSources,\n    draw: (data, outer, dims) => {\n      const inner = deriveParallaxView(getOuterView?.() ?? outer, read());\n      return source.flatMap((layer) => drawOneLayer(layer, data, inner, dims));\n    },\n  };\n}\n"],"mappings":";;;;AAqCA,SAAgBA,EACd,GACoB;CACpB,IAAM,EAAE,OAAI,UAAO,WAAQ,aAAU,oBAAiBC,GAChDC,IAAOC,EAAiBC,CAAQ,UAAUA,EAAS,IAAI,UAAUA,GACjEC,IAAcC,EAAmBC,CAAM;CAC7C,OAAO;EACL;EACA;EACA,OAAO;EACP,WAAWJ,EAAiBC,CAAQ,KAC/B,MAAa;GACd,IAAMI,IAAaH,EAAYI,CAAQ,GACjCC,IAAWN,EAAS,UAAUK,CAAQ;GAC5C,aAAa;IAAgB,AAAdD,EAAW,GAAGE,EAAS;GAAG;EAC3C,IACEL;EACJ,OAAO,GAAM,GAAO,MAAS;GAC3B,IAAMM,IAAQC,EAAmBC,IAAe,KAAKC,GAAOZ,EAAK,CAAC;GAClE,OAAOK,EAAO,SAAS,MAAUQ,EAAaC,GAAOC,GAAMN,GAAOO,CAAI,CAAC;EACzE;CACF;AACF"}

package/dist/features/parallax/createParallaxPlane.js

@@ -1,22 +0,0 @@
-import { createEmitter as e } from "@weasel-js/registry";
-//#region src/features/parallax/createParallaxPlane.ts
-function t(t) {
-	let n = { ...t }, r = e();
-	return {
-		get: () => n,
-		set(e) {
-			n = {
-				...n,
-				...e
-			}, r.emit();
-		},
-		subscribe: r.subscribe
-	};
-}
-function n(e) {
-	return typeof e.get == "function";
-}
-//#endregion
-export { t as createParallaxPlane, n as isParallaxSource };
-
-//# sourceMappingURL=createParallaxPlane.js.map

package/dist/features/parallax/createParallaxPlane.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createParallaxPlane.js","names":["createParallaxPlane","current","initial","listeners","createEmitter","patch","isParallaxSource","p"],"sources":["../../../src/features/parallax/createParallaxPlane.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport type { RedrawSource } from '../../core/layers/render';\nimport type { ParallaxOpts } from '../../core/viewport/parallax';\n\n/** Parallax opts that can change after a layer is built. `get` is read on\n *  every draw, and a notification repaints whatever draws through it. */\nexport interface ParallaxSource extends RedrawSource {\n  get(): ParallaxOpts;\n}\n\n/** A {@link ParallaxSource} you write to — what an animator's `onTick` drives\n *  to tween a plane's `pan`, `zoom` or `anchor`. */\nexport interface ParallaxPlane extends ParallaxSource {\n  /** Merge `patch` over the current opts and notify. */\n  set(patch: Partial<ParallaxOpts>): void;\n}\n\n/** A {@link ParallaxPlane} starting at `initial`. Pass it as a parallax\n *  layer's `parallax` and write to it to move the plane. */\nexport function createParallaxPlane(initial: ParallaxOpts): ParallaxPlane {\n  let current: ParallaxOpts = { ...initial };\n  const listeners = createEmitter();\n  return {\n    get: () => current,\n    set(patch) {\n      current = { ...current, ...patch };\n      listeners.emit();\n    },\n    subscribe: listeners.subscribe,\n  };\n}\n\n/** Whether `p` is a live source rather than a fixed set of opts. */\nexport function isParallaxSource(p: ParallaxOpts | ParallaxSource): p is ParallaxSource {\n  return typeof (p as ParallaxSource).get === 'function';\n}\n"],"mappings":";;AAmBA,SAAgBA,EAAoB,GAAsC;CACxE,IAAIC,IAAwB,EAAE,GAAGC,EAAQ,GACnCC,IAAYC,EAAc;CAChC,OAAO;EACL,WAAWH;EACX,IAAI,GAAO;GAET,AADA,IAAU;IAAE,GAAGA;IAAS,GAAGI;GAAM,GACjCF,EAAU,KAAK;EACjB;EACA,WAAWA,EAAU;CACvB;AACF;AAGA,SAAgBG,EAAiB,GAAuD;CACtF,OAAO,OAAQC,EAAqB,OAAQ;AAC9C"}

package/dist/features/paths/anchorEdits.js

@@ -1,167 +0,0 @@
-import { withinPxRadius as e } from "../../core/viewport/pxExtent.js";
-import { anchorsToPath as t, isAnchorSmooth as n, isStraightSegment as r, nearestSegmentT as i, pathToAnchors as a, segmentEnds as o } from "./anchors.js";
-import { cubicPointAt as s, fitCubicThroughDeletion as c, splitCubicAtT as l } from "@weasel-js/geom";
-//#region src/features/paths/anchorEdits.ts
-function u(e, t) {
-	if (t < 0) return null;
-	let n = t;
-	for (let t = 0; t < e.anchors.length; t++) {
-		let r = e.anchors[t].length;
-		if (n < r) return {
-			sub: t,
-			idx: n
-		};
-		n -= r;
-	}
-	return null;
-}
-function d(e, t, n) {
-	if (t < 0 || t >= e.anchors.length || n < 0 || n >= e.anchors[t].length) return -1;
-	let r = 0;
-	for (let n = 0; n < t; n++) r += e.anchors[n].length;
-	return r + n;
-}
-function f(e, t) {
-	let n = u(e, t);
-	return n ? e.anchors[n.sub][n.idx] ?? null : null;
-}
-function p(e, n) {
-	let r = a(e);
-	return n(r) === !1 ? null : t(r.anchors, r.closed);
-}
-function m(e, t, n, r) {
-	let i = f(e, t);
-	return i ? (i.x += n, i.y += r, i.inHandle && (i.inHandle.x += n, i.inHandle.y += r), i.outHandle && (i.outHandle.x += n, i.outHandle.y += r), !0) : !1;
-}
-function h(e, t, r, i, a, o) {
-	let s = f(e, t);
-	if (!s) return !1;
-	let c = n(s), l = {
-		x: i,
-		y: a
-	};
-	r === "out" ? s.outHandle = l : s.inHandle = l;
-	let u = r === "out" ? "in" : "out", d = u === "in" ? s.inHandle : s.outHandle;
-	if (!o && c && d) {
-		let e = {
-			x: 2 * s.x - l.x,
-			y: 2 * s.y - l.y
-		};
-		u === "in" ? s.inHandle = e : s.outHandle = e;
-	}
-	return !0;
-}
-function g(e, t) {
-	let n = o(e.anchors, e.closed, t.sub, t.segIdx);
-	if (!n) return -1;
-	let { a: i, b: a } = n, s = t.segIdx + 1;
-	if (r(i, a)) return e.anchors[t.sub].splice(s, 0, {
-		x: i.x + (a.x - i.x) * t.t,
-		y: i.y + (a.y - i.y) * t.t
-	}), d(e, t.sub, s);
-	let c = i, u = i.outHandle ?? i, f = a.inHandle ?? a, { left: p, right: m } = l(c, u, f, a, t.t);
-	return i.outHandle = {
-		x: p[1].x,
-		y: p[1].y
-	}, a.inHandle = {
-		x: m[2].x,
-		y: m[2].y
-	}, e.anchors[t.sub].splice(s, 0, {
-		x: p[3].x,
-		y: p[3].y,
-		inHandle: {
-			x: p[2].x,
-			y: p[2].y
-		},
-		outHandle: {
-			x: m[1].x,
-			y: m[1].y
-		}
-	}), d(e, t.sub, s);
-}
-function _(t, n, r, a) {
-	let s = a.scale ?? {
-		x: 1,
-		y: 1
-	}, c = (e) => ({
-		x: e.x * s.x,
-		y: e.y * s.y
-	}), l = t.anchors.map((e) => e.map((e) => ({
-		...c(e),
-		...e.inHandle ? { inHandle: c(e.inHandle) } : {},
-		...e.outHandle ? { outHandle: c(e.outHandle) } : {}
-	}))), u = i(l, n * s.x, r * s.y, t.closed);
-	if (!u) return null;
-	let d = o(t.anchors, t.closed, u.sub, u.segIdx), f = v(d.a, d.b, u.t), p = a.tolerancePx;
-	return !e(f.x - n, f.y - r, p, s) || e(f.x - d.a.x, f.y - d.a.y, p, s) || e(f.x - d.b.x, f.y - d.b.y, p, s) ? null : {
-		sub: u.sub,
-		segIdx: u.segIdx,
-		t: u.t,
-		x: f.x,
-		y: f.y
-	};
-}
-function v(e, t, n) {
-	return r(e, t) ? {
-		x: e.x + (t.x - e.x) * n,
-		y: e.y + (t.y - e.y) * n
-	} : s(e, e.outHandle ?? e, t.inHandle ?? t, t, n);
-}
-function y(e, t) {
-	let n = /* @__PURE__ */ new Map();
-	for (let r of new Set(t)) {
-		let t = u(e, r);
-		if (!t) continue;
-		let i = n.get(t.sub);
-		i ? i.push(t.idx) : n.set(t.sub, [t.idx]);
-	}
-	if (n.size === 0) return !1;
-	let r = 0;
-	for (let t = 0; t < e.anchors.length; t++) {
-		let i = n.get(t)?.length ?? 0;
-		e.anchors[t].length - i >= 2 && r++;
-	}
-	if (r === 0) return !1;
-	for (let [t, r] of n) {
-		let n = e.anchors[t];
-		if (n) {
-			r.sort((e, t) => t - e);
-			for (let i of r) {
-				let r = e.closed[t] && n.length > 2, a = r ? n[(i - 1 + n.length) % n.length] : n[i - 1], o = r ? n[(i + 1) % n.length] : n[i + 1];
-				if (a && o) {
-					let { c1: e, c2: t } = c(a, o);
-					a.outHandle = e, o.inHandle = t;
-				}
-				n.splice(i, 1);
-			}
-		}
-	}
-	for (let t = e.anchors.length - 1; t >= 0; t--) e.anchors[t].length < 2 && (e.anchors.splice(t, 1), e.closed.splice(t, 1));
-	return !0;
-}
-function b(e, t) {
-	let n = u(e, t);
-	if (!n || !e.closed[n.sub]) return !1;
-	let r = e.anchors[n.sub];
-	if (!r) return !1;
-	let { inHandle: i, ...a } = r[n.idx], o = {
-		x: a.x,
-		y: a.y,
-		...i ? { inHandle: i } : {}
-	};
-	return e.anchors[n.sub] = [
-		a,
-		...r.slice(n.idx + 1),
-		...r.slice(0, n.idx),
-		o
-	], e.closed[n.sub] = !1, !0;
-}
-function x(e, t) {
-	let n = t.x + t.width, r = t.y + t.height, i = [], a = 0;
-	for (let o of e.anchors) for (let e of o) e.x >= t.x && e.x <= n && e.y >= t.y && e.y <= r && i.push(a), a++;
-	return i;
-}
-//#endregion
-export { f as anchorAt, x as anchorsInRect, y as deleteAnchorsAt, p as editAnchorSet, d as flatAnchorIndex, g as insertAnchorOnSegment, u as locateAnchor, h as moveHandleTo, b as openSubpathAt, _ as segmentAt, m as translateAnchorBy };
-
-//# sourceMappingURL=anchorEdits.js.map

package/dist/features/paths/anchorEdits.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"anchorEdits.js","names":["p3","locateAnchor","flatIndex","remaining","sub","set","len","flatAnchorIndex","idx","base","s","anchorAt","loc","editAnchorSet","pathToAnchors","path","edit","anchorsToPath","translateAnchorBy","a","dx","dy","moveHandleTo","wasSmooth","isAnchorSmooth","target","toX","toY","side","oppositeSide","opposite","breakSmoothness","mirrored","insertAnchorOnSegment","ends","segmentEnds","args","at","isStraightSegment","b","p0","p1","p2","splitCubicAtT","left","right","segmentAt","scale","opts","onScreen","p","screenAnchors","hit","nearestSegmentT","x","y","point","pointOnSegment","tol","withinPxRadius","t","cubicPointAt","deleteAnchorsAt","bySub","flat","flatIndexes","list","survivors","doomed","indices","wraps","prev","next","fitCubicThroughDeletion","c1","c2","openSubpathAt","start","end","inHandle","anchorsInRect","x2","rect","y2","hits"],"sources":["../../../src/features/paths/anchorEdits.ts"],"sourcesContent":["/**\n * Pure anchor-set edits — the geometry half of path editing, with no\n * dependency on any tool's scratch or on the action layer.\n *\n * The model is the one `pathToAnchors` produces: subpath-major\n * `PenAnchor[][]` plus a parallel `closed: boolean[]`. Every function here\n * mutates that structure in place; callers decode with `pathToAnchors`,\n * apply, and re-encode with `anchorsToPath` (see {@link editAnchorSet}).\n *\n * ## Two ways to name an anchor\n *\n * Callers address anchors by **flat index** — the sequential position in\n * walk order across all subpaths, which is exactly what\n * `enumerateAnchors` reports and therefore what the dispatcher's\n * `anchor:N` / `controlIn:N` / `controlOut:N` affordance kinds carry.\n * Internally, operations that have to reason about subpath structure\n * (deletion, scissors) need the `(sub, idx)` pair instead.\n * {@link locateAnchor} and {@link flatAnchorIndex} convert.\n *\n * The two orders agree because `pathToAnchors` and `enumerateAnchors`\n * walk the same command stream and emit one anchor per M/L/C/Q, less the\n * end of a closing curve that lands on its subpath's first point — see the\n * invariant test in `anchorEdits.test.ts`. `countPathAnchors`, which sizes\n * the renderer's per-anchor arrays, counts that end too and so can be one\n * higher per closed subpath. If you change either walker,\n * that test is the tripwire.\n */\n\nimport { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT, type PolygonPath } from '@weasel-js/geom';\nimport {\n  pathToAnchors,\n  anchorsToPath,\n  isAnchorSmooth,\n  isStraightSegment,\n  nearestSegmentT,\n  segmentEnds,\n  type PenAnchor,\n} from './anchors';\nimport { withinPxRadius, type Scale2 } from 'core/viewport/pxExtent';\n\n/** Subpath-major anchor model — the decoded form of a `PolygonPath`. */\nexport interface AnchorSet {\n  anchors: PenAnchor[][];\n  closed: boolean[];\n}\n\n/** A world-space rectangle, as produced by a drag-rect gesture. */\nexport interface AnchorRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n// ---------------------------------------------------------------------------\n// Addressing\n// ---------------------------------------------------------------------------\n\n/** Total anchors across every subpath. */\nexport function anchorCount(set: AnchorSet): number {\n  let n = 0;\n  for (const sub of set.anchors) n += sub.length;\n  return n;\n}\n\n/** Flat index → `(sub, idx)`. Returns null when out of range. */\nexport function locateAnchor(\n  set: AnchorSet,\n  flatIndex: number,\n): { sub: number; idx: number } | null {\n  if (flatIndex < 0) return null;\n  let remaining = flatIndex;\n  for (let sub = 0; sub < set.anchors.length; sub++) {\n    const len = set.anchors[sub].length;\n    if (remaining < len) return { sub, idx: remaining };\n    remaining -= len;\n  }\n  return null;\n}\n\n/** `(sub, idx)` → flat index. Returns -1 when out of range. */\nexport function flatAnchorIndex(set: AnchorSet, sub: number, idx: number): number {\n  if (sub < 0 || sub >= set.anchors.length) return -1;\n  if (idx < 0 || idx >= set.anchors[sub].length) return -1;\n  let base = 0;\n  for (let s = 0; s < sub; s++) base += set.anchors[s].length;\n  return base + idx;\n}\n\n/** Resolve a flat index to the anchor itself. Null when out of range. */\nexport function anchorAt(set: AnchorSet, flatIndex: number): PenAnchor | null {\n  const loc = locateAnchor(set, flatIndex);\n  if (!loc) return null;\n  return set.anchors[loc.sub][loc.idx] ?? null;\n}\n\n// ---------------------------------------------------------------------------\n// Decode / apply / encode\n// ---------------------------------------------------------------------------\n\n/**\n * Decode `path`, hand the mutable anchor set to `edit`, and re-encode.\n * Returns the new path, or null when `edit` reports that it changed\n * nothing (returning `false`) — callers use that to skip a no-op commit\n * and avoid pushing an empty history entry.\n */\nexport function editAnchorSet(\n  path: PolygonPath,\n  edit: (set: AnchorSet) => boolean | void,\n): PolygonPath | null {\n  const set = pathToAnchors(path) as AnchorSet;\n  const changed = edit(set);\n  if (changed === false) return null;\n  return anchorsToPath(set.anchors, set.closed);\n}\n\n// ---------------------------------------------------------------------------\n// Edits\n// ---------------------------------------------------------------------------\n\n/** Translate an anchor and both of its handles by `(dx, dy)`. */\nexport function translateAnchorBy(\n  set: AnchorSet,\n  flatIndex: number,\n  dx: number,\n  dy: number,\n): boolean {\n  const a = anchorAt(set, flatIndex);\n  if (!a) return false;\n  a.x += dx;\n  a.y += dy;\n  if (a.inHandle) {\n    a.inHandle.x += dx;\n    a.inHandle.y += dy;\n  }\n  if (a.outHandle) {\n    a.outHandle.x += dx;\n    a.outHandle.y += dy;\n  }\n  return true;\n}\n\n/**\n * Move one control handle to an absolute world position.\n *\n * When the anchor was smooth (handles collinear through the anchor) and\n * `breakSmoothness` is false, the opposite handle is mirrored so the curve\n * stays smooth — Illustrator's default. Alt-drag sets `breakSmoothness`\n * and the two handles become independent.\n */\nexport function moveHandleTo(\n  set: AnchorSet,\n  flatIndex: number,\n  side: 'in' | 'out',\n  toX: number,\n  toY: number,\n  breakSmoothness: boolean,\n): boolean {\n  const a = anchorAt(set, flatIndex);\n  if (!a) return false;\n  const wasSmooth = isAnchorSmooth(a);\n  const target = { x: toX, y: toY };\n  if (side === 'out') a.outHandle = target;\n  else a.inHandle = target;\n  const oppositeSide = side === 'out' ? 'in' : 'out';\n  const opposite = oppositeSide === 'in' ? a.inHandle : a.outHandle;\n  if (!breakSmoothness && wasSmooth && opposite) {\n    const mirrored = { x: 2 * a.x - target.x, y: 2 * a.y - target.y };\n    if (oppositeSide === 'in') a.inHandle = mirrored;\n    else a.outHandle = mirrored;\n  }\n  return true;\n}\n\n/**\n * Split the segment `(sub, segIdx) → (sub, segIdx + 1)` at parameter `t`,\n * inserting a new anchor there. On a closed subpath `segIdx` may also name\n * the closing segment (`sub.length - 1`); its new anchor is appended.\n *\n * A straight segment splits linearly and stays straight — the new anchor\n * has no handles. A curved one splits by de Casteljau, which preserves the\n * curve exactly: the two halves trace the original path.\n *\n * Returns the new anchor's flat index, or -1 when the segment doesn't\n * exist.\n */\nexport function insertAnchorOnSegment(\n  set: AnchorSet,\n  args: { sub: number; segIdx: number; t: number },\n): number {\n  const ends = segmentEnds(set.anchors, set.closed, args.sub, args.segIdx);\n  if (!ends) return -1;\n  const { a, b } = ends;\n  const at = args.segIdx + 1;\n  if (isStraightSegment(a, b)) {\n    set.anchors[args.sub].splice(at, 0, {\n      x: a.x + (b.x - a.x) * args.t,\n      y: a.y + (b.y - a.y) * args.t,\n    });\n    return flatAnchorIndex(set, args.sub, at);\n  }\n  const p0 = a, p1 = a.outHandle ?? a, p2 = b.inHandle ?? b, p3 = b;\n  const { left, right } = splitCubicAtT(p0, p1, p2, p3, args.t);\n  a.outHandle = { x: left[1].x, y: left[1].y };\n  b.inHandle = { x: right[2].x, y: right[2].y };\n  set.anchors[args.sub].splice(at, 0, {\n    x: left[3].x,\n    y: left[3].y,\n    inHandle: { x: left[2].x, y: left[2].y },\n    outHandle: { x: right[1].x, y: right[1].y },\n  });\n  return flatAnchorIndex(set, args.sub, at);\n}\n\n/** A point on a segment, as {@link segmentAt} reports it. */\nexport interface SegmentHit {\n  sub: number;\n  segIdx: number;\n  /** Parameter on the segment — what {@link insertAnchorOnSegment} takes. */\n  t: number;\n  /** The point on the path at `t`, in the set's own space. */\n  x: number;\n  y: number;\n}\n\n/**\n * The segment point under `(x, y)`, when it lies within `tolerancePx` of\n * the path on screen and no nearer than that to either of the segment's\n * own anchors — a press on an anchor is about the anchor, not the segment\n * beside it.\n *\n * `scale` is the view's, so the tolerance holds per axis under\n * non-uniform zoom. The search runs in screen-scaled space: scaling is\n * affine, so the curve's parameterization, and therefore `t`, carries\n * straight back to world space.\n */\nexport function segmentAt(\n  set: AnchorSet,\n  x: number,\n  y: number,\n  opts: { tolerancePx: number; scale?: Scale2 },\n): SegmentHit | null {\n  const scale = opts.scale ?? { x: 1, y: 1 };\n  const onScreen = (p: { x: number; y: number }) => ({ x: p.x * scale.x, y: p.y * scale.y });\n  const screenAnchors = set.anchors.map((sub) => sub.map((a) => ({\n    ...onScreen(a),\n    ...(a.inHandle ? { inHandle: onScreen(a.inHandle) } : {}),\n    ...(a.outHandle ? { outHandle: onScreen(a.outHandle) } : {}),\n  })));\n  const hit = nearestSegmentT(screenAnchors, x * scale.x, y * scale.y, set.closed);\n  if (!hit) return null;\n  const ends = segmentEnds(set.anchors, set.closed, hit.sub, hit.segIdx)!;\n  const point = pointOnSegment(ends.a, ends.b, hit.t);\n  const tol = opts.tolerancePx;\n  if (!withinPxRadius(point.x - x, point.y - y, tol, scale)) return null;\n  if (withinPxRadius(point.x - ends.a.x, point.y - ends.a.y, tol, scale)) return null;\n  if (withinPxRadius(point.x - ends.b.x, point.y - ends.b.y, tol, scale)) return null;\n  return { sub: hit.sub, segIdx: hit.segIdx, t: hit.t, x: point.x, y: point.y };\n}\n\nfunction pointOnSegment(a: PenAnchor, b: PenAnchor, t: number): { x: number; y: number } {\n  if (isStraightSegment(a, b)) return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };\n  return cubicPointAt(a, a.outHandle ?? a, b.inHandle ?? b, b, t);\n}\n\n/**\n * Delete the anchors at `flatIndexes`. Where a deleted anchor had\n * neighbors on both sides — across the seam too, on a closed subpath — the\n * surviving segment is refitted through the gap (`fitCubicThroughDeletion`)\n * so the path keeps its shape instead of snapping to a straight line.\n *\n * Subpaths left with fewer than two anchors are dropped entirely — a\n * one-anchor subpath has no segments and would serialize to a stray `M`.\n *\n * If that would leave the path with **no** subpaths at all, the whole\n * deletion is refused (returns false, `set` untouched). Committing an\n * empty path turns the node into an invisible zombie: still selected,\n * still in the scene, nothing on screen and no anchors left to grab it\n * by. Deleting the object is the node-level Delete action's job, and the\n * user asked to delete anchors.\n */\nexport function deleteAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>): boolean {\n  const bySub = new Map<number, number[]>();\n  for (const flat of new Set(flatIndexes)) {\n    const loc = locateAnchor(set, flat);\n    if (!loc) continue;\n    const list = bySub.get(loc.sub);\n    if (list) list.push(loc.idx);\n    else bySub.set(loc.sub, [loc.idx]);\n  }\n  if (bySub.size === 0) return false;\n\n  // Refuse up front if this would wipe the path out — cheaper and safer\n  // than mutating and rolling back.\n  let survivors = 0;\n  for (let s = 0; s < set.anchors.length; s++) {\n    const doomed = bySub.get(s)?.length ?? 0;\n    if (set.anchors[s].length - doomed >= 2) survivors++;\n  }\n  if (survivors === 0) return false;\n\n  for (const [s, indices] of bySub) {\n    const sub = set.anchors[s];\n    if (!sub) continue;\n    // Descending so each splice leaves the not-yet-processed indices valid.\n    indices.sort((a, b) => b - a);\n    for (const i of indices) {\n      const wraps = set.closed[s] && sub.length > 2;\n      const prev = wraps ? sub[(i - 1 + sub.length) % sub.length] : sub[i - 1];\n      const next = wraps ? sub[(i + 1) % sub.length] : sub[i + 1];\n      if (prev && next) {\n        const { c1, c2 } = fitCubicThroughDeletion(prev, next);\n        prev.outHandle = c1;\n        next.inHandle = c2;\n      }\n      sub.splice(i, 1);\n    }\n  }\n\n  // Drop degenerate subpaths, back to front so indices stay valid.\n  for (let s = set.anchors.length - 1; s >= 0; s--) {\n    if (set.anchors[s].length < 2) {\n      set.anchors.splice(s, 1);\n      set.closed.splice(s, 1);\n    }\n  }\n  return true;\n}\n\n/**\n * Scissors: open a closed subpath at the given anchor. The anchor list is\n * rotated to start there and a second anchor at the same point ends it, so\n * every segment survives and the two ends can be pulled apart. No-ops on an\n * already-open subpath — there's nothing to cut.\n */\nexport function openSubpathAt(set: AnchorSet, flatIndex: number): boolean {\n  const loc = locateAnchor(set, flatIndex);\n  if (!loc) return false;\n  if (!set.closed[loc.sub]) return false;\n  const sub = set.anchors[loc.sub];\n  if (!sub) return false;\n  const { inHandle, ...start } = sub[loc.idx];\n  const end: PenAnchor = { x: start.x, y: start.y, ...(inHandle ? { inHandle } : {}) };\n  set.anchors[loc.sub] = [start, ...sub.slice(loc.idx + 1), ...sub.slice(0, loc.idx), end];\n  set.closed[loc.sub] = false;\n  return true;\n}\n\n/** Flat indices of every anchor whose on-curve point falls inside `rect`. */\nexport function anchorsInRect(set: AnchorSet, rect: AnchorRect): number[] {\n  const x2 = rect.x + rect.width;\n  const y2 = rect.y + rect.height;\n  const hits: number[] = [];\n  let flat = 0;\n  for (const sub of set.anchors) {\n    for (const a of sub) {\n      if (a.x >= rect.x && a.x <= x2 && a.y >= rect.y && a.y <= y2) hits.push(flat);\n      flat++;\n    }\n  }\n  return hits;\n}\n"],"mappings":"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"}

package/dist/features/paths/anchors.js

@@ -1,159 +0,0 @@
-import { PATH_C as e, PATH_L as t, PATH_M as n, PATH_Q as r, PATH_Z as i, PathBuilder as a, forEachSegment as o, nearestOnCubic as s, nearestOnLine as c } from "@weasel-js/geom";
-//#region src/features/paths/anchors.ts
-function l(a) {
-	let { commands: s, coords: c } = a, l = [], d = [], f = null;
-	return o(s, c, (a, o) => {
-		switch (a) {
-			case n:
-				f && (l.push(f), d.push(!1)), f = [{
-					x: c[o],
-					y: c[o + 1]
-				}];
-				break;
-			case t:
-				if (!f) throw Error("pathToAnchors: L without prior M");
-				f.push({
-					x: c[o],
-					y: c[o + 1]
-				});
-				break;
-			case e: {
-				if (!f) throw Error("pathToAnchors: C without prior M");
-				let e = f[f.length - 1];
-				e.outHandle = {
-					x: c[o],
-					y: c[o + 1]
-				}, f.push({
-					x: c[o + 4],
-					y: c[o + 5],
-					inHandle: {
-						x: c[o + 2],
-						y: c[o + 3]
-					}
-				});
-				break;
-			}
-			case r: {
-				if (!f) throw Error("pathToAnchors: Q without prior M");
-				let e = {
-					x: c[o],
-					y: c[o + 1]
-				}, t = f[f.length - 1];
-				t.outHandle = e, f.push({
-					x: c[o + 2],
-					y: c[o + 3],
-					inHandle: { ...e }
-				});
-				break;
-			}
-			case i:
-				f &&= (u(f), l.push(f), d.push(!0), null);
-				break;
-			default: throw Error(`pathToAnchors: unknown command ${a}`);
-		}
-	}), f && (l.push(f), d.push(!1)), {
-		anchors: l,
-		closed: d
-	};
-}
-function u(e) {
-	if (e.length < 2) return;
-	let t = e[0], n = e[e.length - 1];
-	n.inHandle && n.x === t.x && n.y === t.y && (e.pop(), t.inHandle = n.inHandle);
-}
-function d(e, t) {
-	let n = new a();
-	for (let r = 0; r < e.length; r++) {
-		let i = e[r];
-		if (i.length !== 0) {
-			n.moveTo(i[0].x, i[0].y);
-			for (let e = 1; e < i.length; e++) {
-				let t = i[e - 1], r = i[e];
-				if (t.outHandle == null && r.inHandle == null) n.lineTo(r.x, r.y);
-				else {
-					let e = t.outHandle ?? {
-						x: t.x,
-						y: t.y
-					}, i = r.inHandle ?? {
-						x: r.x,
-						y: r.y
-					};
-					n.curveTo(e.x, e.y, i.x, i.y, r.x, r.y);
-				}
-			}
-			if (t[r]) {
-				let e = i[i.length - 1], t = i[0];
-				if (e.outHandle != null || t.inHandle != null) {
-					let r = e.outHandle ?? {
-						x: e.x,
-						y: e.y
-					}, i = t.inHandle ?? {
-						x: t.x,
-						y: t.y
-					};
-					n.curveTo(r.x, r.y, i.x, i.y, t.x, t.y);
-				}
-				n.close();
-			}
-		}
-	}
-	return n.build();
-}
-var f = .001;
-function p(e) {
-	if (!e.inHandle || !e.outHandle) return !1;
-	let t = e.inHandle.x - e.x, n = e.inHandle.y - e.y, r = e.outHandle.x - e.x, i = e.outHandle.y - e.y, a = Math.hypot(t, n), o = Math.hypot(r, i);
-	if (a === 0 || o === 0) return !1;
-	let s = (t * i - n * r) / (a * o);
-	return Math.abs(s) < f;
-}
-function m(i) {
-	if (i.kind === "rect") return 4;
-	let a = i.commands, o = 0;
-	for (let i = 0; i < a.length; i++) {
-		let s = a[i];
-		(s === n || s === t || s === e || s === r) && o++;
-	}
-	return o;
-}
-function h(e, t, n, r) {
-	let i = e[n];
-	return !i || r < 0 ? null : r + 1 < i.length ? {
-		a: i[r],
-		b: i[r + 1]
-	} : t?.[n] && i.length > 1 && r === i.length - 1 ? {
-		a: i[r],
-		b: i[0]
-	} : null;
-}
-function g(e, t) {
-	return e.outHandle == null && t.inHandle == null;
-}
-function _(e, t, n, r) {
-	let i = e.outHandle ?? e, a = t.inHandle ?? t, o = g(e, t) ? c(n, r, e.x, e.y, t.x, t.y) : s(n, r, e.x, e.y, i.x, i.y, a.x, a.y, t.x, t.y);
-	return {
-		t: o.t,
-		d2: o.dist * o.dist
-	};
-}
-function v(e, t, n, r) {
-	let i = Infinity, a = null;
-	for (let o = 0; o < e.length; o++) {
-		let s = e[o].length - +!r?.[o];
-		for (let c = 0; c < s; c++) {
-			let s = h(e, r, o, c);
-			if (!s) continue;
-			let l = _(s.a, s.b, t, n);
-			l.d2 < i && (i = l.d2, a = {
-				sub: o,
-				segIdx: c,
-				t: l.t
-			});
-		}
-	}
-	return a;
-}
-//#endregion
-export { d as anchorsToPath, m as countPathAnchors, p as isAnchorSmooth, g as isStraightSegment, v as nearestSegmentT, l as pathToAnchors, h as segmentEnds };
-
-//# sourceMappingURL=anchors.js.map