@trokster/l-cursor 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hrakotom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# Infinite Zoom
+
+A semantic-zoom visualization library: one generic engine driving a **radial
+fractal** you can fall into forever. As you zoom in, the camera re-bases its
+referential (see [`THEORY.md`](./THEORY.md)) so the scale number never escapes a
+~3-decade band and floating-point precision never rots. Off-screen and sub-pixel
+nodes are never drawn — render cost is `O(visible)`, independent of tree size.
+
+## Demo (`npm run dev`)
+
+`/zoom/radial` — children ring inside each node; click to dive, wheel/pinch to
+zoom, drag to pan, zoom out to rise. Each node carries a live **HTML portal** (a
+real component sized in screen pixels) that swaps detail as you approach.
+
+## Architecture
+
+- `core/engine.js` — generic engine: bounded-scale camera, referential rebasing
+  (the infinite-zoom trick), level-of-detail with ghost child previews, sibling
+  context, and viewport culling. Display-agnostic.
+- `core/{camera,rebase,interaction,tree}.js` — affine camera, the pixel-exact
+  rebase math, pointer/pinch/wheel + inertia, shared tree indexing.
+- `layouts/radial.js` — `layout(index, rootId, opts)` returning `{ nodes, order }`.
+  The engine is generic over any self-similar, child-contained layout; radial is
+  the one shipped here.
+- `viz/ZoomScene.svelte` — the renderer: world-static SVG under a single animated
+  transform, spring fly-to navigation, breadcrumbs, enter-fades, and
+  resolution-adaptive HTML **portals** (live components inside each node's core).
+
+```js
+import { ZoomScene, indexTree, radialLayout } from '@trokster/l-cursor';
+// <ZoomScene index={indexTree(data)} layout={radialLayout} nodeStyle="rings" />
+```
+
+The math (rebase derivation, LOD, culling, self-similarity) lives in
+[`THEORY.md`](./THEORY.md). A copy-paste integration guide for LLMs/agents is in
+[`LLM.md`](./LLM.md).
+
+## Develop
+
+```bash
+npm install
+npm run dev          # SvelteKit playground at /zoom/radial
+npm run test:unit -- --run   # Vitest (engine + component, headless)
+npm run lint         # Prettier + ESLint
+npm run build        # package the library to dist/ (svelte-package + publint)
+```
+
+The package is Svelte 5 (runes) and SVG-only — no canvas, WebGL, or runtime
+dependencies. `import` from `@trokster/l-cursor` in any SvelteKit/Vite project.

package/dist/core/camera.d.ts

@@ -0,0 +1,30 @@
+export function createCamera(initial?: {}): {
+    state: import("svelte/store").Writable<{
+        x: any;
+        y: any;
+        sx: any;
+        sy: any;
+    }>;
+    get: () => {
+        x: any;
+        y: any;
+        sx: any;
+        sy: any;
+    };
+    set: (p: any) => void;
+    pan: (dx: any, dy: any) => void;
+    zoomAt: (factor: any, cx: any, cy: any) => void;
+    zoomAtXY: (fx: any, fy: any, cx: any, cy: any) => void;
+    worldToScreen: (wx: any, wy: any, s?: {
+        x: any;
+        y: any;
+        sx: any;
+        sy: any;
+    }) => any[];
+    screenToWorld: (px: any, py: any, s?: {
+        x: any;
+        y: any;
+        sx: any;
+        sy: any;
+    }) => number[];
+};

package/dist/core/camera.js

@@ -0,0 +1,80 @@
+import { writable, get } from 'svelte/store';
+
+// Affine camera, per-axis. World -> screen is:
+//
+//     screenX = worldX * sx + x
+//     screenY = worldY * sy + y
+//
+// Uniform layouts (radial / pack / network) keep sx === sy. Treemap allows
+// sx !== sy (rectangles stretch per axis). See THEORY.md §3.
+//
+// We do NOT clamp scale here — the engine rebases (THEORY.md §4) to keep scale
+// inside a healthy band, which is a cleaner mechanism than hard clamping.
+
+export function createCamera(initial = {}) {
+	const state = writable({
+		x: initial.x ?? 0,
+		y: initial.y ?? 0,
+		sx: initial.sx ?? initial.scale ?? 1,
+		sy: initial.sy ?? initial.scale ?? 1
+	});
+
+	function set(p) {
+		state.update((s) => {
+			const next = { ...s };
+			if (p.x != null) next.x = p.x;
+			if (p.y != null) next.y = p.y;
+			if (p.scale != null) {
+				next.sx = p.scale;
+				next.sy = p.scale;
+			}
+			if (p.sx != null) next.sx = p.sx;
+			if (p.sy != null) next.sy = p.sy;
+			return next;
+		});
+	}
+
+	function pan(dx, dy) {
+		state.update((s) => ({ ...s, x: s.x + dx, y: s.y + dy }));
+	}
+
+	// Uniform zoom toward screen point (cx, cy) keeping that world point fixed.
+	function zoomAt(factor, cx, cy) {
+		state.update((s) => {
+			const nsx = s.sx * factor;
+			const nsy = s.sy * factor;
+			const wx = (cx - s.x) / s.sx;
+			const wy = (cy - s.y) / s.sy;
+			return { sx: nsx, sy: nsy, x: cx - wx * nsx, y: cy - wy * nsy };
+		});
+	}
+
+	// Anisotropic zoom (treemap): independent factors per axis.
+	function zoomAtXY(fx, fy, cx, cy) {
+		state.update((s) => {
+			const nsx = s.sx * fx;
+			const nsy = s.sy * fy;
+			const wx = (cx - s.x) / s.sx;
+			const wy = (cy - s.y) / s.sy;
+			return { sx: nsx, sy: nsy, x: cx - wx * nsx, y: cy - wy * nsy };
+		});
+	}
+
+	function worldToScreen(wx, wy, s = get(state)) {
+		return [wx * s.sx + s.x, wy * s.sy + s.y];
+	}
+	function screenToWorld(px, py, s = get(state)) {
+		return [(px - s.x) / s.sx, (py - s.y) / s.sy];
+	}
+
+	return {
+		state,
+		get: () => get(state),
+		set,
+		pan,
+		zoomAt,
+		zoomAtXY,
+		worldToScreen,
+		screenToWorld
+	};
+}

package/dist/core/engine.d.ts

@@ -0,0 +1,67 @@
+export function createEngine({ index, layout, camera, config }: {
+    index: any;
+    layout: any;
+    camera: any;
+    config?: {};
+}): {
+    setViewport: (w: any, h: any) => void;
+    fit: (frac?: number) => void;
+    fitCamera: (frac?: number) => {
+        sx: number;
+        sy: number;
+        x: number;
+        y: number;
+    };
+    frame: () => {
+        items: {
+            id: any;
+            parentId: any;
+            kind: any;
+            depth: any;
+            absDepth: any;
+            childCount: any;
+            data: any;
+            open: boolean;
+            openness: any;
+            leaf: boolean;
+            alpha: any;
+            showLabel: boolean;
+        }[];
+        rootId: any;
+        cam: any;
+        edges: any;
+        links: {
+            id: string;
+            x1: any;
+            y1: any;
+            x2: any;
+            y2: any;
+            r1: any;
+            r2: any;
+            alpha: any;
+        }[];
+    };
+    reset: (id: any) => void;
+    setAnchor: (x: any, y: any) => void;
+    clearAnchor: () => void;
+    pick: (px: any, py: any) => any;
+    readonly rootId: any;
+    readonly config: {
+        rootSize: number;
+        maxDepth: number;
+        contextUp: number;
+        treeLinks: boolean;
+        descendAt: number;
+        ascendAt: number;
+        minPx: number;
+        openPx: number;
+        childPreview: boolean;
+        previewPx: number;
+        previewMax: number;
+        labelPx: number;
+        maxScale: number;
+        minScale: number;
+        layoutOpts: {};
+    };
+    readonly layout: any;
+};