@jamesyong42/infinite-canvas 1.2.0 → 1.4.0

package/dist/index-3GY7T8JM.d.mts

@@ -0,0 +1,480 @@
+import { S as DomWidgetProps, T as Widget, r as LayoutEngine, w as R3FWidgetProps } from "./index-Dj9odADH.mjs";
+import * as _$_jamesyong42_reactive_ecs0 from "@jamesyong42/reactive-ecs";
+import { EntityId } from "@jamesyong42/reactive-ecs";
+import * as _$react from "react";
+import * as THREE from "three";
+import { BufferGeometry, Material, OrthographicCamera, Scene, ShaderMaterial, Texture, Vector2, Vector3, WebGLRenderTarget } from "three";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/react/context/container-ref-context.d.ts
+declare const ContainerRefProvider: _$react.Provider<_$react.RefObject<HTMLDivElement | null> | null>;
+declare function useContainerRef(): React.RefObject<HTMLDivElement | null> | null;
+//#endregion
+//#region src/react/context/engine-context.d.ts
+declare const EngineProvider: _$react.Provider<LayoutEngine<Widget> | null>;
+/**
+ * Returns the LayoutEngine instance from the nearest InfiniteCanvas context.
+ * Throws if used outside an InfiniteCanvas provider.
+ */
+declare function useLayoutEngine(): LayoutEngine;
+//#endregion
+//#region src/react/context/widget-resolver-context.d.ts
+/**
+ * Discriminated resolution of a widget by type. The surface determines which
+ * layer renders the component and with what prop shape.
+ */
+type ResolvedWidget = {
+  surface: 'dom';
+  component: React.ComponentType<DomWidgetProps>;
+} | {
+  surface: 'webgl';
+  component: React.ComponentType<R3FWidgetProps>;
+};
+type WidgetResolver = (entityId: EntityId, widgetType: string) => ResolvedWidget | null;
+declare const WidgetResolverProvider: _$react.Provider<WidgetResolver | null>;
+declare function useWidgetResolver(): WidgetResolver | null;
+//#endregion
+//#region src/webgl/renderers/GridRenderer.d.ts
+interface GridConfig {
+  /** World-unit spacings for up to 3 grid levels [fine, medium, coarse]. */
+  spacings: [number, number, number];
+  /** Dot RGB color as [r, g, b] in 0–1 range. */
+  dotColor: [number, number, number];
+  /** Base dot opacity multiplier (0–1). */
+  dotAlpha: number;
+  /** CSS-pixel range where a grid level fades in: [start, end]. */
+  fadeIn: [number, number];
+  /** CSS-pixel range where a grid level fades out: [start, end]. */
+  fadeOut: [number, number];
+  /** Dot radius range in CSS pixels [min, max]. Scaled by DPR internally. */
+  dotRadius: [number, number];
+  /** Per-level opacity weight: level i gets (base + i * step). */
+  levelWeight: [number, number];
+}
+declare const DEFAULT_GRID_CONFIG: GridConfig;
+/**
+ * Draws the infinite dot-grid background into a THREE.WebGLRenderer.
+ * The renderer is owned by the parent (see {@link WebGLManager}) — this class
+ * only contributes a scene, camera, and shader material.
+ */
+declare class GridRenderer {
+  private scene;
+  private camera;
+  private material;
+  private mesh;
+  constructor();
+  /** Apply a (partial) grid config. Only provided fields are updated. */
+  setConfig(config: Partial<GridConfig>): void;
+  setSize(width: number, height: number, dpr?: number): void;
+  render(renderer: THREE.WebGLRenderer, cameraX: number, cameraY: number, zoom: number): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/webgl/renderers/SelectionRenderer.d.ts
+interface SelectionConfig {
+  /** Selection outline color [r,g,b] 0-1. Default: Figma blue. */
+  outlineColor: [number, number, number];
+  /** Selection outline width in screen px. */
+  outlineWidth: number;
+  /** Hover outline color [r,g,b] 0-1. */
+  hoverColor: [number, number, number];
+  /** Hover outline width in screen px. */
+  hoverWidth: number;
+  /** Handle size in screen px. */
+  handleSize: number;
+  /** Handle fill color [r,g,b] 0-1 (white). */
+  handleFill: [number, number, number];
+  /** Handle border color [r,g,b] 0-1 (same as outline). */
+  handleBorder: [number, number, number];
+  /** Handle border width in screen px. */
+  handleBorderWidth: number;
+  /** Group bbox dash length in screen px (0 = solid). */
+  groupDash: number;
+}
+declare const DEFAULT_SELECTION_CONFIG: SelectionConfig;
+interface SelectionBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/**
+ * Draws selection outlines, 8 resize handles, group-bbox, and the hover
+ * outline in a single SDF-based shader pass. Snap guides and equal-
+ * spacing indicators are a separate concern — see {@link SnapGuideRenderer}.
+ *
+ * The `THREE.WebGLRenderer` is owned by the parent ({@link WebGLManager})
+ * and passed to each render call so grid + selection can share a single
+ * GL context and accumulate `renderer.info` counters for the same tick.
+ */
+declare class SelectionRenderer {
+  private material;
+  private mesh;
+  private scene;
+  private camera;
+  constructor();
+  setConfig(config: Partial<SelectionConfig>): void;
+  setSize(resolution: THREE.Vector2, dpr: number): void;
+  render(renderer: THREE.WebGLRenderer, cameraX: number, cameraY: number, zoom: number, selected: SelectionBounds[], hovered: SelectionBounds | null): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/webgl/renderers/SnapGuideRenderer.d.ts
+interface SnapGuideConfig {
+  /** Guide line + spacing indicator color [r,g,b] 0-1. */
+  color: [number, number, number];
+  /** Line width in world pixels (constant across zoom). */
+  lineWidth: number;
+  /** Guide alpha (full-canvas alignment lines). */
+  guideAlpha: number;
+  /** Equal-spacing indicator alpha. */
+  spacingAlpha: number;
+}
+declare const DEFAULT_SNAP_GUIDE_CONFIG: SnapGuideConfig;
+//#endregion
+//#region src/r3f/compositor/ResourceRegistry.d.ts
+/**
+ * Archetype-keyed cache of GPU resources shared across per-widget scenes
+ * (RFC-002 § Three.js resource sharing).
+ *
+ * Geometries, materials, and textures returned by `acquire*` are reference
+ * counted. The registry disposes the underlying resource only after every
+ * holder has called the matching `release*` — so 100 widgets of the same
+ * card archetype share one geometry instance and one set of material
+ * uniforms, rather than allocating 100 copies.
+ */
+declare class ResourceRegistry {
+  private geometries;
+  private materials;
+  private textures;
+  private disposed;
+  acquireGeometry<T extends BufferGeometry>(key: string, factory: () => T): T;
+  releaseGeometry(key: string): void;
+  acquireMaterial<T extends Material>(key: string, factory: () => T): T;
+  releaseMaterial(key: string): void;
+  acquireTexture<T extends Texture>(key: string, factory: () => T): T;
+  releaseTexture(key: string): void;
+  /** Number of distinct shared geometries currently held. */
+  geometryCount(): number;
+  /** Number of distinct shared materials currently held. */
+  materialCount(): number;
+  /** Number of distinct shared textures currently held. */
+  textureCount(): number;
+  /**
+   * Estimated GPU bytes for shared geometry attribute buffers. Best-effort —
+   * actual GPU footprint depends on driver alignment, but this is a useful
+   * relative metric for the profiler.
+   */
+  geometryBytes(): number;
+  /** Dispose every resource and clear the registry. */
+  dispose(): void;
+  /** True after `dispose()` — callers should re-create the registry instead of using it. */
+  isDisposed(): boolean;
+  private release;
+}
+//#endregion
+//#region src/r3f/compositor/WidgetRenderTargetPool.d.ts
+/** Snapshot returned by {@link WidgetRenderTargetPool.entries}. */
+type PoolEntryInfo = {
+  entityId: EntityId;
+  bytes: number;
+  lastUsedMs: number;
+};
+/**
+ * Allocates one persistent `WebGLRenderTarget` per R3F widget entity. Used
+ * by the compositor (RFC-002 Phase 4) so each widget paints into its own
+ * texture instead of into the main canvas backbuffer.
+ *
+ * Acquire returns an existing FBO if its pixel resolution matches the
+ * request; otherwise the old FBO is disposed and a new one created (sized
+ * to the new resolution). Eviction under memory pressure is Phase 6 — this
+ * pool grows monotonically until widgets are released.
+ */
+declare class WidgetRenderTargetPool {
+  private entries;
+  private totalBytes;
+  private disposed;
+  /**
+   * Get or create an FBO for `entityId` at the requested logical size and
+   * device pixel ratio. If an FBO already exists at the same pixel
+   * dimensions, returns it unchanged.
+   */
+  acquire(entityId: EntityId, width: number, height: number, dpr: number): WebGLRenderTarget;
+  /** Look up an FBO without creating one. */
+  get(entityId: EntityId): WebGLRenderTarget | null;
+  /**
+   * Refresh `lastUsedMs` without re-acquiring. The Compositor calls this
+   * for every widget it samples in the composition pass — without it,
+   * Warm widgets that never repaint would freeze their `lastUsedMs` at
+   * the time of their last paint, and eviction LRU would treat
+   * still-visible widgets as stale.
+   */
+  touch(entityId: EntityId): void;
+  /**
+   * Release `entityId`'s FBO. Returns true if something was released.
+   * Safe to call after dispose — returns false rather than corrupting the
+   * byte counter or double-disposing the target.
+   */
+  release(entityId: EntityId): boolean;
+  /** Total GPU bytes consumed by the pool. */
+  bytesUsed(): number;
+  /** Number of FBOs currently held. */
+  size(): number;
+  /** True after `dispose()` — callers should re-create the pool instead of using it. */
+  isDisposed(): boolean;
+  /** Iterate live entries. */
+  forEach(cb: (entityId: EntityId, rt: WebGLRenderTarget) => void): void;
+  /**
+   * Snapshot of every live entry's `bytes` + `lastUsedMs` — input for the
+   * eviction algorithm in {@link selectEvictions}.
+   */
+  entryInfos(): PoolEntryInfo[];
+  /** Dispose every FBO. After this, acquire throws and release returns false. */
+  dispose(): void;
+}
+//#endregion
+//#region src/r3f/compositor/CompositorContext.d.ts
+/**
+ * Per-widget registration entry the Compositor needs in order to paint
+ * the widget's scene into its FBO each frame.
+ */
+type CompositorWidgetEntry = {
+  scene: Scene;
+  camera: OrthographicCamera;
+  /**
+   * Bumped by the widget when its content has changed and needs a repaint.
+   * Compared against fboGeneration in R3FRenderState.
+   */
+  requestRepaint: () => void;
+};
+type CompositorContextValue = {
+  pool: WidgetRenderTargetPool;
+  registry: ResourceRegistry;
+  register: (entityId: EntityId, entry: CompositorWidgetEntry) => () => void;
+};
+declare const CompositorContext: _$react.Context<CompositorContextValue | null>;
+declare function useCompositor(): CompositorContextValue;
+//#endregion
+//#region src/r3f/compositor/WidgetRegistry.d.ts
+/**
+ * Stable per-canvas registry of R3F widget scenes + cameras (RFC-006).
+ *
+ * Created in `R3FManager` so it's reachable both by the `Compositor`
+ * (which adds/removes widgets as `VirtualWidget` mounts) and by the
+ * R3F event factory (which resolves the active widget by entityId
+ * returned from `engine.pickAt`, then looks up its scene + camera here).
+ *
+ * Plain Map under the hood — the wrapping class exists to give the
+ * registry a stable identity across React renders and to keep the read
+ * surface (`get`, `keys`, `all`) discoverable from both consumers.
+ */
+declare class WidgetRegistry {
+  private readonly entries;
+  register(entityId: EntityId, entry: CompositorWidgetEntry): () => void;
+  get(entityId: EntityId): CompositorWidgetEntry | undefined;
+  all(): IterableIterator<[EntityId, CompositorWidgetEntry]>;
+  keys(): IterableIterator<EntityId>;
+  values(): IterableIterator<CompositorWidgetEntry>;
+  clear(): void;
+}
+//#endregion
+//#region src/r3f/compositor/Compositor.d.ts
+/**
+ * Drives the per-widget paint + composition render loop (RFC-002 Phase 4).
+ *
+ * Lifecycle each invalidation:
+ *   1. For every registered widget whose phase is Hot or Waking (or whose
+ *      paintGeneration > fboGeneration), bind its FBO and render its scene
+ *      with its widget-local camera.
+ *   2. Update each widget's composition quad (position, scale, texture).
+ *   3. Render the composition scene to the canvas backbuffer with a
+ *      world-space orthographic camera matching the engine camera.
+ *
+ * Owns the `WidgetRenderTargetPool`. Children mount `<VirtualWidget />`
+ * instances which register their scene+camera via context.
+ *
+ * Replaces the old `R3FWidgetSlot` + `CameraSync` pair.
+ */
+declare function Compositor({
+  engine,
+  widgetRegistry,
+  children
+}: {
+  engine: LayoutEngine;
+  /**
+   * Stable per-canvas widget registry created in `R3FManager`. Shared
+   * with the R3F event factory so the EventRouter (RFC-006) can resolve
+   * which widget owns a pointer event without a separate registration
+   * path. The Compositor populates it on `register` / unregister; reads
+   * it back during the paint + composition loop.
+   */
+  widgetRegistry: WidgetRegistry;
+  children: React.ReactNode;
+}): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/r3f/compositor/state.d.ts
+/**
+ * Compositor state-machine phase for an R3F widget (RFC-002).
+ *
+ * - `Hot`     — Active + Visible + animating. Ticks + paints every invalidation.
+ * - `Warm`    — Active + Visible + idle. Texture cached, no tick, no paint.
+ * - `Waking`  — Active + Visible but no valid texture yet (just un-culled / un-dormant). One-shot paint then → `Warm`.
+ * - `Cold`    — Active + Culled. Off-screen, texture eviction-eligible.
+ * - `Dormant` — Not Active. Eviction-protected so re-activation is instant.
+ */
+type R3FPhase = 'Hot' | 'Warm' | 'Cold' | 'Waking' | 'Dormant';
+/** Pixel resolution + camera zoom at which a widget's texture was last painted. */
+type R3FPaintedAt = {
+  width: number;
+  height: number;
+  dpr: number;
+  zoom: number;
+};
+/** Per-widget state tracked by the compositor. */
+type R3FRenderStateData = {
+  phase: R3FPhase;
+  paintedAt: R3FPaintedAt; /** True while the widget has signalled an animation tick is in progress. */
+  animating: boolean; /** Bumped by widget state changes / animations that invalidate the texture. */
+  paintGeneration: number; /** Generation last successfully painted into the FBO. */
+  fboGeneration: number;
+};
+declare const R3FRenderState: _$_jamesyong42_reactive_ecs0.ComponentType<R3FRenderStateData>;
+/**
+ * Opt-in tag — a widget that wants per-frame ticking sets this. The state
+ * machine treats `Visible + R3FAnimationSignal` as the trigger for `Hot`.
+ * Removing the tag transitions back to `Warm` when the widget settles.
+ */
+declare const R3FAnimationSignal: _$_jamesyong42_reactive_ecs0.TagType;
+/** Global compositor memory + stagger budget. */
+type R3FRenderBudgetData = {
+  /** Max bytes the widget render-target pool may consume. */maxBytes: number; /** Current pool consumption (written by the pool once it lands in Phase 4). */
+  currentBytes: number; /** Max widgets to repaint per composited frame. */
+  maxRepaintsPerFrame: number;
+};
+declare const R3FRenderBudget: _$_jamesyong42_reactive_ecs0.ResourceType<R3FRenderBudgetData>;
+//#endregion
+//#region src/r3f/compositor/hooks.d.ts
+/**
+ * Marks the current R3F widget as actively animating. While `active` is true,
+ * the state machine places the widget in `Hot`; when false, it returns to
+ * `Warm` on the next frame.
+ *
+ * Widgets should call this whenever they want per-frame ticking (e.g. during
+ * a spring settle, hover lerp, or an external animation). Without this
+ * signal, `useFrame` bodies may still fire when the canvas re-renders for
+ * other reasons — check `useWidgetPhase() === 'Hot'` to early-exit work
+ * that's only meaningful during the animation.
+ */
+declare function useWidgetAnimation(entityId: EntityId, active: boolean): void;
+/**
+ * Returns the current compositor phase for the widget. Re-renders when the
+ * phase changes.
+ */
+declare function useWidgetPhase(entityId: EntityId): R3FPhase | null;
+/**
+ * Returns a function that schedules a one-shot repaint of the widget. Use
+ * when widget content changes outside of React's render cycle (e.g., a
+ * subscription to an external store, an imperative WebSocket message).
+ *
+ * Internally bumps `paintGeneration` so the compositor's dirty check picks
+ * the widget up on the next frame, and invalidates the canvas so that
+ * frame is actually scheduled.
+ */
+declare function useWidgetInvalidate(entityId: EntityId): () => void;
+/**
+ * Acquires a shared geometry from the Compositor's `ResourceRegistry`,
+ * keyed by `cacheKey`. The factory runs only on first acquisition; later
+ * callers with the same key get the same instance. Released automatically
+ * on unmount; the registry disposes when the last holder releases.
+ *
+ * Use for geometries that are expensive to build and frequently identical
+ * across widget instances — e.g. preset card backs.
+ */
+declare function useSharedGeometry<T extends BufferGeometry>(cacheKey: string, factory: () => T): T;
+/** Same contract as {@link useSharedGeometry}, for materials. */
+declare function useSharedMaterial<T extends Material>(cacheKey: string, factory: () => T): T;
+/** Same contract as {@link useSharedGeometry}, for textures. */
+declare function useSharedTexture<T extends Texture>(cacheKey: string, factory: () => T): T;
+//#endregion
+//#region src/r3f/compositor/VirtualWidget.d.ts
+/**
+ * Mounts one R3F widget into its own Three.js scene + ortho camera so it
+ * can be painted into a private `WebGLRenderTarget` instead of the main
+ * canvas backbuffer.
+ *
+ * The user component is rendered in widget-local space — origin at centre,
+ * X right, Y up, dimensions = (Transform2D.width, Transform2D.height) in
+ * frame-local world units.
+ * That matches the contract the previous `R3FWidgetSlot` exposed, so user
+ * widget code (e.g. `geometry-card`) needs no changes.
+ *
+ * VirtualWidget itself does not paint or composite — that's the
+ * Compositor's job. We just create the scene/camera and register them so
+ * the Compositor can iterate widgets in its render loop.
+ */
+declare function VirtualWidget({
+  entityId,
+  component: Component
+}: {
+  entityId: EntityId;
+  component: React.ComponentType<R3FWidgetProps>;
+}): _$react.JSX.Element | null;
+//#endregion
+//#region src/r3f/compositor/WidgetStateMachine.d.ts
+/**
+ * Updates `R3FRenderState` phases for every R3F (`surface === 'webgl'`)
+ * widget after each engine tick.
+ *
+ * At this phase the state machine is bookkeeping only — it does not
+ * allocate or paint render targets (that arrives in Phase 4). Consumers
+ * such as widget `useFrame` callbacks read the phase to decide whether
+ * to do work this frame.
+ *
+ * Transition rules match RFC-002 § State machine:
+ *
+ *   Active + Visible + R3FAnimationSignal → Hot
+ *   Active + Visible (idle)               → Warm (or Waking if texture invalid — irrelevant pre-Phase-4)
+ *   Active + Culled                       → Cold
+ *   !Active                               → Dormant
+ */
+declare function WidgetStateMachine({
+  engine
+}: {
+  engine: LayoutEngine;
+}): null;
+//#endregion
+//#region src/r3f/compositor/ZoomBands.d.ts
+/**
+ * Hysteresis-banded zoom-resolution policy (RFC-002 § Zoom handling).
+ *
+ * A widget's FBO is allocated at `widget bounds × dpr × band(zoom)` pixels.
+ * As long as the camera zoom stays within `[band × 0.5, band × 2]` of the
+ * band the widget was painted at, no repaint is needed — the composition
+ * shader does a small up/down sample. Crossing that gap triggers a repaint
+ * at the new band, snapping back to a 1:1 (or near-1:1) sample ratio.
+ *
+ * Bands are powers of 2 so each band covers a 4× display range. With the
+ * default ladder (0.0625 ↔ 16) we span camera zooms 0.03125 ↔ 32 — covering
+ * essentially every realistic infinite-canvas zoom level.
+ */
+declare const ZOOM_BANDS: readonly [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16];
+/**
+ * Pick the band whose `[band × 0.5, band × 2]` range contains the current
+ * zoom. The smallest band ≥ zoom (after rounding to a band edge) is the
+ * canonical choice — keeps the texture resolution at or above what the
+ * display needs.
+ */
+declare function selectBand(zoom: number): number;
+/**
+ * Returns true if the widget needs to be repainted because the camera
+ * zoom has wandered outside the tolerance window of the band it was
+ * painted at.
+ *
+ * `paintedBand` of 0 (or negative) means the widget has never been
+ * painted yet — caller should treat that as "needs paint" through other
+ * channels (Waking phase / paintGeneration > fboGeneration).
+ */
+declare function isOutOfBand(currentZoom: number, paintedBand: number): boolean;
+//#endregion
+export { SelectionConfig as A, ContainerRefProvider as B, useCompositor as C, SnapGuideConfig as D, DEFAULT_SNAP_GUIDE_CONFIG as E, ResolvedWidget as F, WidgetResolverProvider as I, useWidgetResolver as L, DEFAULT_GRID_CONFIG as M, GridConfig as N, DEFAULT_SELECTION_CONFIG as O, GridRenderer as P, EngineProvider as R, CompositorWidgetEntry as S, ResourceRegistry as T, useContainerRef as V, R3FRenderState as _, VirtualWidget as a, CompositorContext as b, useSharedTexture as c, useWidgetPhase as d, R3FAnimationSignal as f, R3FRenderBudgetData as g, R3FRenderBudget as h, WidgetStateMachine as i, SelectionRenderer as j, SelectionBounds as k, useWidgetAnimation as l, R3FPhase as m, isOutOfBand as n, useSharedGeometry as o, R3FPaintedAt as p, selectBand as r, useSharedMaterial as s, ZOOM_BANDS as t, useWidgetInvalidate as u, R3FRenderStateData as v, WidgetRenderTargetPool as w, CompositorContextValue as x, Compositor as y, useLayoutEngine as z };
+//# sourceMappingURL=index-3GY7T8JM.d.mts.map

package/dist/index-3GY7T8JM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-3GY7T8JM.d.mts","names":[],"sources":["../src/react/context/container-ref-context.ts","../src/react/context/engine-context.ts","../src/react/context/widget-resolver-context.ts","../src/webgl/renderers/GridRenderer.ts","../src/webgl/renderers/SelectionRenderer.ts","../src/webgl/renderers/SnapGuideRenderer.ts","../src/r3f/compositor/ResourceRegistry.ts","../src/r3f/compositor/WidgetRenderTargetPool.ts","../src/r3f/compositor/CompositorContext.tsx","../src/r3f/compositor/WidgetRegistry.ts","../src/r3f/compositor/Compositor.tsx","../src/r3f/compositor/state.ts","../src/r3f/compositor/hooks.ts","../src/r3f/compositor/VirtualWidget.tsx","../src/r3f/compositor/WidgetStateMachine.tsx","../src/r3f/compositor/ZoomBands.ts"],"mappings":"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"}