npm - @invana/graph-layer-d3-contour - Versions diffs - 0.0.1 - Mend

@invana/graph-layer-d3-contour 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,276 @@
+import { EventMap, WorldLayer, WorldLayerHit, LayerOptions, CanvasContext } from '@invana/canvas';
+import { ContourMultiPolygon } from 'd3-contour';
+import { Graphics } from 'pixi.js';
+/**
+ * Built-in colour ramps for {@link DensityContourLayer}.
+ *
+ * Each palette is an ordered array of `0xRRGGBB` stops from low-density to
+ * high-density. The layer interpolates between adjacent stops so any band
+ * count (3, 10, 30...) lands on a perceptually-smooth colour.
+ *
+ * Sequential single-hue palettes (`blues`, `greens`, ...) are drawn from
+ * ColorBrewer; perceptual ramps (`viridis`, `plasma`, `magma`, `inferno`)
+ * are 10-stop quantizations of matplotlib's perceptual colour maps. `warm`
+ * and `cool` are ColorBrewer YlOrRd / BuPu equivalents.
+ */
+type DensityContourPaletteName = 'blues' | 'greens' | 'oranges' | 'purples' | 'reds' | 'viridis' | 'plasma' | 'magma' | 'inferno' | 'warm' | 'cool';
+declare const DENSITY_CONTOUR_PALETTES: Record<DensityContourPaletteName, number[]>;
+/** All built-in palette names in declaration order. Useful for GUI menus. */
+declare const DENSITY_CONTOUR_PALETTE_NAMES: readonly DensityContourPaletteName[];
+/**
+ * Linear interpolation between two `0xRRGGBB` colours in sRGB space.
+ * `t` is clamped to `[0, 1]`. sRGB-linear is "good enough" for adjacent
+ * stops in a smooth ramp; for perceptually-uniform mixing across distant
+ * hues, supply a function via `paletteFn`.
+ */
+declare function lerpColor(a: number, b: number, t: number): number;
+/**
+ * Linearly interpolate a `0xRRGGBB` colour from a stop array based on the
+ * band's position `(index / (total - 1))`. Returns the last stop if there's
+ * only one band or one stop.
+ */
+declare function sampleStops(stops: number[], index: number, total: number): number;
+/**
+ * Options shared by every `DensityContourLayer*` — the d3-contour compute
+ * inputs and the recompute lifecycle. Both {@link DensityContourFillLayer}
+ * and {@link DensityContourStrokeLayer} extend this; their layer-specific
+ * presentation knobs live on their own options interfaces.
+ */
+interface DensityContourLayerBaseOptions {
+    /**
+     * Required. Id of the `GraphLayer` whose node positions feed the density
+     * estimate. Per canvas architecture: cross-layer deps are declared
+     * explicitly, never inferred.
+     */
+    graphLayerId: string;
+    /**
+     * Kernel bandwidth in world units. Larger = smoother / broader blobs.
+     * Defaults to `20` (d3's own default).
+     */
+    bandwidth?: number;
+    /**
+     * Either a count of iso-bands or an explicit array of iso-values. Defaults
+     * to `10`. With a number, d3-contour picks evenly-spaced thresholds across
+     * the value range.
+     */
+    thresholds?: number | number[];
+    /**
+     * Grid cell size in world units. Smaller = sharper bands but quadratically
+     * more compute. d3 requires a power of two (1, 2, 4, 8, 16). Defaults to `4`.
+     */
+    cellSize?: number;
+    /**
+     * Padding added around the node bounding box before building the grid, so
+     * bands at the edge of the cluster aren't clipped against the grid border.
+     * World units. Defaults to `50`.
+     */
+    padding?: number;
+    /**
+     * Recompute trigger:
+     * - `'auto'` (default) — subscribe to the source layer's `data:changed`
+     *   and recompute on a debounce.
+     * - `'manual'` — caller drives recompute via `layer.recompute()`.
+     */
+    recompute?: 'auto' | 'manual';
+    /** Debounce window for `auto` recomputes. Default `120` ms. */
+    recomputeDebounceMs?: number;
+}
+/**
+ * The palette-resolution chain shared by both layers. The fill layer
+ * consumes it to colour bands; the stroke layer consumes it when
+ * `strokeColor: 'palette'`. Resolution order (most specific wins):
+ * `fillColor` callback (fill layer only) > `paletteFn(t)` >
+ * `paletteRangeStart`/`paletteRangeEnd` (only when BOTH set) > `palette`
+ * (name or stop array) > default `'blues'`.
+ */
+interface DensityContourPaletteOptions {
+    palette?: DensityContourPaletteName | number[];
+    paletteRangeStart?: number;
+    paletteRangeEnd?: number;
+    paletteFn?: (t: number) => number;
+}
+/**
+ * Options for {@link DensityContourFillLayer}. Paints filled iso-bands and
+ * nothing else — no stroke. For an outline-only look use
+ * {@link DensityContourStrokeLayer}; compose both layers (same
+ * `graphLayerId`, different `zIndex`) for fill + outline together.
+ */
+interface DensityContourFillLayerOptions extends DensityContourLayerBaseOptions, DensityContourPaletteOptions {
+    /**
+     * Fully-custom fill colour per band. Receives `(value, index, total)` and
+     * returns a `0xRRGGBB` integer. `value` is the iso-value (density);
+     * `index` runs 0..total-1 from low-density to high-density. Wins over
+     * every other palette option.
+     */
+    fillColor?: (value: number, index: number, total: number) => number;
+    /** Fill alpha 0..1. Defaults to `0.4`. */
+    fillOpacity?: number;
+}
+/**
+ * Options for {@link DensityContourStrokeLayer}. Paints iso-line outlines
+ * and nothing else — no fill. Defaults match Observable's
+ * [`@d3/density-contours`](https://observablehq.com/@d3/density-contours):
+ * steelblue strokes, every 5th band stroked at 1 unit, the rest at 0.25
+ * (the topographic "index contour" pattern).
+ */
+interface DensityContourStrokeLayerOptions extends DensityContourLayerBaseOptions, DensityContourPaletteOptions {
+    /**
+     * Band outline colour.
+     *
+     * - `0xRRGGBB` → constant colour for every band. Default `0x4682b4`
+     *   (steelblue, Observable's default).
+     * - `'palette'` → resolved per band through the palette chain above
+     *   ({@link paletteFn} > range > {@link palette}). Use this for the
+     *   "rainbow iso-lines" look.
+     */
+    strokeColor?: number | 'palette';
+    /**
+     * Band outline width. Either a constant or a per-band function that
+     * receives `(index, total, value)` and returns a width in world units.
+     *
+     * The function form is the most general — useful for any pattern where
+     * width depends on `index`. For the canonical topo-map "every Nth line
+     * heavy" look, prefer the declarative {@link indexEvery}/
+     * {@link indexMajorWidth}/{@link indexMinorWidth} sugar below.
+     *
+     * Default `0.5`.
+     */
+    strokeWidth?: number | ((index: number, total: number, value: number) => number);
+    /**
+     * Index-contour sugar — every `indexEvery`-th band (counting from
+     * low-density at `i=0`) is stroked with {@link indexMajorWidth}, all
+     * others with {@link indexMinorWidth}. Reproduces the topographic
+     * "index contour every N lines" pattern used by Observable's
+     * `@d3/density-contours`.
+     *
+     * Precedence: function-form {@link strokeWidth} wins over the sugar (so
+     * callers can opt fully out by setting `strokeWidth` to a callback). The
+     * sugar wins over numeric {@link strokeWidth}. All three sugar fields
+     * must be set together; partial setups fall back to {@link strokeWidth}.
+     *
+     * Defaults reproduce Observable's example: `indexEvery: 5`,
+     * `indexMajorWidth: 1`, `indexMinorWidth: 0.25`.
+     */
+    indexEvery?: number;
+    indexMajorWidth?: number;
+    indexMinorWidth?: number;
+}
+/**
+ * Reserved. Neither layer currently projects user-mutated state — the
+ * computed contour data is held as a private field, not in `Layer.state`,
+ * because it's bulk geometry that's rebuilt wholesale on each recompute
+ * rather than diffed.
+ */
+interface DensityContourLayerState {
+    readonly _placeholder?: never;
+}
+interface DensityContourLayerEvents extends EventMap {
+    /** Fired after each recompute completes, before paint. */
+    recompute: {
+        thresholds: number;
+        points: number;
+        durationMs: number;
+    };
+}
+/**
+ * `DensityContourLayerBase` — abstract `WorldLayer` that owns the
+ * d3-contour density compute and recompute lifecycle. Concrete subclasses
+ * decide *how* the resulting iso-bands are painted: filled
+ * ({@link DensityContourFillLayer}) or stroked
+ * ({@link DensityContourStrokeLayer}).
+ *
+ * The compute lives in world space so iso-bands track the source graph as
+ * the camera pans and zooms. Recompute is debounced (default 120 ms) and
+ * triggered by the source `GraphLayer`'s `data:changed`. `contourDensity`
+ * is O(n · grid²), so per-frame recompute during drag would tank perf —
+ * set `recompute: 'manual'` and call `layer.recompute()` from a drag
+ * behaviour if you need that.
+ *
+ * Subclasses implement {@link paintDensity} to render the
+ * `ContourMultiPolygon[]` into the layer's `Graphics`. All shared state
+ * (subscription, debounce timer, bounds math) is owned here.
+ */
+declare abstract class DensityContourLayerBase<TOpt extends DensityContourLayerBaseOptions, TEvt extends DensityContourLayerEvents = DensityContourLayerEvents> extends WorldLayer<TOpt, DensityContourLayerState, TEvt, never, WorldLayerHit> {
+    private readonly graphLayerId;
+    private graph;
+    protected gfx: Graphics | null;
+    private readonly subs;
+    private debounceTimer;
+    constructor(opts: LayerOptions<TOpt>);
+    protected createState(): DensityContourLayerState;
+    protected onMount(ctx: CanvasContext): void;
+    protected onUnmount(): void;
+    /**
+     * Force an immediate recompute. Useful in `recompute: 'manual'` mode, or
+     * to refresh the overlay after externally mutating options that don't
+     * have setters yet.
+     */
+    recompute(): void;
+    hitTest(_worldX: number, _worldY: number): WorldLayerHit | null;
+    private scheduleRecompute;
+    private computeAndPaint;
+    /**
+     * Render the iso-bands into `g`. The bands are ordered low-density →
+     * high-density; subclasses typically paint in that order so denser bands
+     * sit on top. `offsetX`/`offsetY` are the world-space origin of the
+     * compute grid — add them to each polygon point.
+     */
+    protected abstract paintDensity(g: Graphics, density: ContourMultiPolygon[], offsetX: number, offsetY: number): void;
+}
+/**
+ * `DensityContourFillLayer` — paints filled iso-bands from a
+ * d3-contour density estimate over a source `GraphLayer`'s node positions.
+ * No outline. For the stroked / Observable-style look, use
+ * {@link DensityContourStrokeLayer}; compose both layers (same
+ * `graphLayerId`, different `zIndex`) for fill + outline together.
+ */
+declare class DensityContourFillLayer extends DensityContourLayerBase<DensityContourFillLayerOptions> {
+    protected paintDensity(g: Graphics, density: ContourMultiPolygon[], offsetX: number, offsetY: number): void;
+    /**
+     * Resolve the palette chain into a per-band colour function. Order
+     * (most specific wins): {@link DensityContourFillLayerOptions.fillColor}
+     * > `paletteFn(t)` > `paletteRangeStart`/`paletteRangeEnd` (both set) >
+     * `palette` > default `'blues'`.
+     */
+    private resolveFillColor;
+}
+/**
+ * `DensityContourStrokeLayer` — paints stroked iso-lines from a
+ * d3-contour density estimate over a source `GraphLayer`'s node positions.
+ * No fill. Defaults reproduce Observable's
+ * [`@d3/density-contours`](https://observablehq.com/@d3/density-contours):
+ * steelblue strokes with the topographic "index contour" pattern (every 5th
+ * band heavy at 1 unit, the rest hair-thin at 0.25).
+ *
+ * For filled iso-bands use {@link DensityContourFillLayer}; compose both
+ * layers (same `graphLayerId`, different `zIndex`) for fill + outline
+ * together.
+ */
+declare class DensityContourStrokeLayer extends DensityContourLayerBase<DensityContourStrokeLayerOptions> {
+    protected paintDensity(g: Graphics, density: ContourMultiPolygon[], offsetX: number, offsetY: number): void;
+    /**
+     * Resolve the per-band stroke-width function. Precedence:
+     *   1. `strokeWidth` is a function → use it directly.
+     *   2. All three index-contour sugar fields set → build
+     *      `(i) => i % every === 0 ? major : minor`.
+     *   3. `strokeWidth` is a number → constant.
+     *   4. Default {@link STROKE_DEFAULTS.strokeWidth}.
+     */
+    private resolveWidth;
+    /**
+     * Resolve the per-band stroke-colour function. When `strokeColor` is
+     * `'palette'`, walk the palette chain (`paletteFn` > range > `palette`);
+     * otherwise return a constant colour function. Default is steelblue.
+     */
+    private resolveStrokeColor;
+}
+export { DENSITY_CONTOUR_PALETTES, DENSITY_CONTOUR_PALETTE_NAMES, DensityContourFillLayer, type DensityContourFillLayerOptions, DensityContourLayerBase, type DensityContourLayerBaseOptions, type DensityContourLayerEvents, type DensityContourLayerState, type DensityContourPaletteName, type DensityContourPaletteOptions, DensityContourStrokeLayer, type DensityContourStrokeLayerOptions, lerpColor, sampleStops };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,391 @@
+import { WorldLayer } from '@invana/canvas';
+import { contourDensity } from 'd3-contour';
+// src/DensityContourLayerBase.ts
+var DENSITY_CONTOUR_BASE_DEFAULTS = {
+  bandwidth: 20,
+  thresholds: 10,
+  cellSize: 4,
+  padding: 50,
+  recompute: "auto",
+  recomputeDebounceMs: 120
+};
+var DensityContourLayerBase = class extends WorldLayer {
+  graphLayerId;
+  graph = null;
+  gfx = null;
+  subs = [];
+  // Browser `setTimeout` returns `number`; using `ReturnType<typeof setTimeout>`
+  // would resolve to NodeJS.Timeout in dual-typed environments and break the
+  // `window.clearTimeout(...)` call site.
+  debounceTimer = null;
+  constructor(opts) {
+    super({
+      ...opts,
+      // Density bands extend past node centres by `bandwidth + padding`, so
+      // viewport culling against the bare node AABB would clip them.
+      cullable: opts.cullable ?? false,
+      // Passive overlay — clicks fall through to the graph below.
+      hittable: opts.hittable ?? false
+    });
+    this.graphLayerId = opts.options.graphLayerId;
+  }
+  createState() {
+    return {};
+  }
+  onMount(ctx) {
+    const graph = ctx.layers.get(this.graphLayerId);
+    if (!graph) {
+      throw new Error(
+        `${this.constructor.name} "${this.id}": graph layer "${this.graphLayerId}" not found. Add the GraphLayer before this contour layer.`
+      );
+    }
+    this.graph = graph;
+    this.gfx = this.createGraphics("density-bands");
+    const recompute = this.options.recompute ?? DENSITY_CONTOUR_BASE_DEFAULTS.recompute;
+    if (recompute === "auto") {
+      this.subs.push(graph.events.on("data:changed", () => this.scheduleRecompute()));
+    }
+    this.scheduleRecompute();
+  }
+  onUnmount() {
+    for (const off of this.subs) off();
+    this.subs.length = 0;
+    if (this.debounceTimer !== null) {
+      window.clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    this.gfx = null;
+    this.graph = null;
+  }
+  /**
+   * Force an immediate recompute. Useful in `recompute: 'manual'` mode, or
+   * to refresh the overlay after externally mutating options that don't
+   * have setters yet.
+   */
+  recompute() {
+    this.computeAndPaint();
+  }
+  hitTest(_worldX, _worldY) {
+    return null;
+  }
+  // ─── Internals ─────────────────────────────────────────────────────────────
+  scheduleRecompute() {
+    if (this.debounceTimer !== null) window.clearTimeout(this.debounceTimer);
+    const wait = this.options.recomputeDebounceMs ?? DENSITY_CONTOUR_BASE_DEFAULTS.recomputeDebounceMs;
+    this.debounceTimer = window.setTimeout(() => {
+      this.debounceTimer = null;
+      this.computeAndPaint();
+    }, wait);
+  }
+  computeAndPaint() {
+    const g = this.gfx;
+    const graph = this.graph;
+    if (!g || !graph) return;
+    const t0 = performance.now();
+    const points = [];
+    for (const node of graph.store.nodes()) {
+      const p = node.position;
+      if (!p) continue;
+      points.push({ x: p.x, y: p.y });
+    }
+    g.clear();
+    if (points.length === 0) return;
+    const pad = this.options.padding ?? DENSITY_CONTOUR_BASE_DEFAULTS.padding;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const p of points) {
+      if (p.x < minX) minX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y > maxY) maxY = p.y;
+    }
+    minX -= pad;
+    minY -= pad;
+    maxX += pad;
+    maxY += pad;
+    const width = Math.max(1, Math.ceil(maxX - minX));
+    const height = Math.max(1, Math.ceil(maxY - minY));
+    const density = contourDensity().x((d) => d.x - minX).y((d) => d.y - minY).size([width, height]).bandwidth(this.options.bandwidth ?? DENSITY_CONTOUR_BASE_DEFAULTS.bandwidth).thresholds(this.options.thresholds ?? DENSITY_CONTOUR_BASE_DEFAULTS.thresholds).cellSize(this.options.cellSize ?? DENSITY_CONTOUR_BASE_DEFAULTS.cellSize)(points);
+    this.paintDensity(g, density, minX, minY);
+    this.events.emit(
+      "recompute",
+      {
+        thresholds: density.length,
+        points: points.length,
+        durationMs: performance.now() - t0
+      }
+    );
+  }
+};
+// src/palettes.ts
+var DENSITY_CONTOUR_PALETTES = {
+  blues: [
+    16251903,
+    14609399,
+    13032431,
+    10406625,
+    7057110,
+    4362950,
+    2191797,
+    545180,
+    536683
+  ],
+  greens: [
+    16252149,
+    15070688,
+    13101504,
+    10607003,
+    7652470,
+    4303709,
+    2329413,
+    27948,
+    17435
+  ],
+  oranges: [
+    16774635,
+    16705230,
+    16634018,
+    16625259,
+    16616764,
+    15821075,
+    14239745,
+    10892803,
+    8333060
+  ],
+  purples: [
+    16579581,
+    15724021,
+    14342891,
+    12369372,
+    10394312,
+    8420794,
+    6967715,
+    5515151,
+    4128893
+  ],
+  reds: [
+    16774640,
+    16703698,
+    16563105,
+    16552562,
+    16476746,
+    15678252,
+    13309981,
+    10817301,
+    6750221
+  ],
+  viridis: [
+    4456788,
+    4728952,
+    4082057,
+    3238030,
+    2523790,
+    2072201,
+    3520377,
+    7261784,
+    11918891,
+    16639781
+  ],
+  plasma: [
+    854151,
+    4588447,
+    7471528,
+    10229662,
+    12400518,
+    14178155,
+    15563091,
+    16424507,
+    16632358,
+    15792417
+  ],
+  magma: [
+    4,
+    1576765,
+    4460406,
+    7479169,
+    10366847,
+    13451377,
+    15818845,
+    16619112,
+    16697997,
+    16580031
+  ],
+  inferno: [
+    4,
+    1772609,
+    4852843,
+    7871597,
+    10824800,
+    13583430,
+    15558949,
+    16488966,
+    16240957,
+    16580516
+  ],
+  warm: [16772512, 16701814, 16691788, 16616764, 16535082, 14883356, 11599910],
+  cool: [14740724, 12571622, 10403034, 9213638, 9202609, 8929693, 7209323]
+};
+var DENSITY_CONTOUR_PALETTE_NAMES = Object.keys(
+  DENSITY_CONTOUR_PALETTES
+);
+function lerpColor(a, b, t) {
+  const u = t <= 0 ? 0 : t >= 1 ? 1 : t;
+  const ar = a >> 16 & 255;
+  const ag = a >> 8 & 255;
+  const ab = a & 255;
+  const br = b >> 16 & 255;
+  const bg = b >> 8 & 255;
+  const bb = b & 255;
+  const r = Math.round(ar + (br - ar) * u);
+  const g = Math.round(ag + (bg - ag) * u);
+  const bl = Math.round(ab + (bb - ab) * u);
+  return r << 16 | g << 8 | bl;
+}
+function sampleStops(stops, index, total) {
+  if (stops.length === 0) return 0;
+  if (total <= 1 || stops.length === 1) return stops[stops.length - 1];
+  const t = index / (total - 1);
+  const pos = Math.max(0, Math.min(1, t)) * (stops.length - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.min(stops.length - 1, lo + 1);
+  return lerpColor(stops[lo], stops[hi], pos - lo);
+}
+// src/DensityContourFillLayer.ts
+var FILL_DEFAULTS = {
+  fillOpacity: 0.4,
+  palette: "blues"
+};
+function resolveStops(palette) {
+  if (Array.isArray(palette)) return palette;
+  const name = palette ?? FILL_DEFAULTS.palette;
+  return DENSITY_CONTOUR_PALETTES[name] ?? DENSITY_CONTOUR_PALETTES[FILL_DEFAULTS.palette];
+}
+var DensityContourFillLayer = class extends DensityContourLayerBase {
+  paintDensity(g, density, offsetX, offsetY) {
+    const opacity = this.options.fillOpacity ?? FILL_DEFAULTS.fillOpacity;
+    const total = density.length;
+    const colorAt = this.resolveFillColor();
+    density.forEach((band, i) => {
+      const fillColor = colorAt(band.value, i, total);
+      for (const polygon of band.coordinates) {
+        const outer = polygon[0];
+        if (!outer || outer.length < 3) continue;
+        const flat = new Array(outer.length * 2);
+        for (let k = 0; k < outer.length; k++) {
+          const pt = outer[k];
+          flat[k * 2] = (pt[0] ?? 0) + offsetX;
+          flat[k * 2 + 1] = (pt[1] ?? 0) + offsetY;
+        }
+        g.poly(flat);
+      }
+      g.fill({ color: fillColor, alpha: opacity });
+    });
+  }
+  /**
+   * Resolve the palette chain into a per-band colour function. Order
+   * (most specific wins): {@link DensityContourFillLayerOptions.fillColor}
+   * > `paletteFn(t)` > `paletteRangeStart`/`paletteRangeEnd` (both set) >
+   * `palette` > default `'blues'`.
+   */
+  resolveFillColor() {
+    const o = this.options;
+    if (o.fillColor) return o.fillColor;
+    if (o.paletteFn) {
+      const fn = o.paletteFn;
+      return (_v, i, n) => fn(n > 1 ? i / (n - 1) : 0);
+    }
+    if (o.paletteRangeStart !== void 0 && o.paletteRangeEnd !== void 0) {
+      const a = o.paletteRangeStart;
+      const b = o.paletteRangeEnd;
+      return (_v, i, n) => lerpColor(a, b, n > 1 ? i / (n - 1) : 0);
+    }
+    const stops = resolveStops(o.palette);
+    return (_v, i, n) => sampleStops(stops, i, n);
+  }
+};
+// src/DensityContourStrokeLayer.ts
+var STROKE_DEFAULTS = {
+  strokeColor: 4620980,
+  // steelblue — Observable's default
+  strokeWidth: 0.5,
+  palette: "blues"
+};
+function resolveStops2(palette) {
+  if (Array.isArray(palette)) return palette;
+  const name = palette ?? STROKE_DEFAULTS.palette;
+  return DENSITY_CONTOUR_PALETTES[name] ?? DENSITY_CONTOUR_PALETTES[STROKE_DEFAULTS.palette];
+}
+var DensityContourStrokeLayer = class extends DensityContourLayerBase {
+  paintDensity(g, density, offsetX, offsetY) {
+    const total = density.length;
+    const widthAt = this.resolveWidth();
+    const strokeAt = this.resolveStrokeColor();
+    density.forEach((band, i) => {
+      const w = widthAt(i, total, band.value);
+      if (w <= 0) return;
+      for (const polygon of band.coordinates) {
+        const outer = polygon[0];
+        if (!outer || outer.length < 3) continue;
+        const flat = new Array(outer.length * 2);
+        for (let k = 0; k < outer.length; k++) {
+          const pt = outer[k];
+          flat[k * 2] = (pt[0] ?? 0) + offsetX;
+          flat[k * 2 + 1] = (pt[1] ?? 0) + offsetY;
+        }
+        g.poly(flat);
+      }
+      g.stroke({ color: strokeAt(band.value, i, total), width: w });
+    });
+  }
+  /**
+   * Resolve the per-band stroke-width function. Precedence:
+   *   1. `strokeWidth` is a function → use it directly.
+   *   2. All three index-contour sugar fields set → build
+   *      `(i) => i % every === 0 ? major : minor`.
+   *   3. `strokeWidth` is a number → constant.
+   *   4. Default {@link STROKE_DEFAULTS.strokeWidth}.
+   */
+  resolveWidth() {
+    const o = this.options;
+    if (typeof o.strokeWidth === "function") return o.strokeWidth;
+    if (o.indexEvery !== void 0 && o.indexMajorWidth !== void 0 && o.indexMinorWidth !== void 0) {
+      const every = o.indexEvery;
+      const major = o.indexMajorWidth;
+      const minor = o.indexMinorWidth;
+      return (i) => i % every === 0 ? major : minor;
+    }
+    const w = typeof o.strokeWidth === "number" ? o.strokeWidth : STROKE_DEFAULTS.strokeWidth;
+    return () => w;
+  }
+  /**
+   * Resolve the per-band stroke-colour function. When `strokeColor` is
+   * `'palette'`, walk the palette chain (`paletteFn` > range > `palette`);
+   * otherwise return a constant colour function. Default is steelblue.
+   */
+  resolveStrokeColor() {
+    const o = this.options;
+    const sc = o.strokeColor;
+    if (sc === "palette") {
+      if (o.paletteFn) {
+        const fn = o.paletteFn;
+        return (_v, i, n) => fn(n > 1 ? i / (n - 1) : 0);
+      }
+      if (o.paletteRangeStart !== void 0 && o.paletteRangeEnd !== void 0) {
+        const a = o.paletteRangeStart;
+        const b = o.paletteRangeEnd;
+        return (_v, i, n) => lerpColor(a, b, n > 1 ? i / (n - 1) : 0);
+      }
+      const stops = resolveStops2(o.palette);
+      return (_v, i, n) => sampleStops(stops, i, n);
+    }
+    const c = typeof sc === "number" ? sc : STROKE_DEFAULTS.strokeColor;
+    return () => c;
+  }
+};
+export { DENSITY_CONTOUR_PALETTES, DENSITY_CONTOUR_PALETTE_NAMES, DensityContourFillLayer, DensityContourLayerBase, DensityContourStrokeLayer, lerpColor, sampleStops };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["../src/DensityContourLayerBase.ts","../src/palettes.ts","../src/DensityContourFillLayer.ts","../src/DensityContourStrokeLayer.ts"],"names":["resolveStops"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * `DensityContourLayerBase` — abstract `WorldLayer` that owns the\n * d3-contour density compute and recompute lifecycle. Concrete subclasses\n * decide *how* the resulting iso-bands are painted: filled\n * ({@link DensityContourFillLayer}) or stroked\n * ({@link DensityContourStrokeLayer}).\n *\n * The compute lives in world space so iso-bands track the source graph as\n * the camera pans and zooms. Recompute is debounced (default 120 ms) and\n * triggered by the source `GraphLayer`'s `data:changed`. `contourDensity`\n * is O(n · grid²), so per-frame recompute during drag would tank perf —\n * set `recompute: 'manual'` and call `layer.recompute()` from a drag\n * behaviour if you need that.\n *\n * Subclasses implement {@link paintDensity} to render the\n * `ContourMultiPolygon[]` into the layer's `Graphics`. All shared state\n * (subscription, debounce timer, bounds math) is owned here.\n */\n\nimport { WorldLayer } from '@invana/canvas';\nimport type { CanvasContext, LayerOptions, WorldLayerHit } from '@invana/canvas';\nimport { GraphLayer } from '@invana/graph';\nimport { contourDensity, type ContourMultiPolygon } from 'd3-contour';\nimport type { Graphics } from 'pixi.js';\n\nimport type {\n DensityContourLayerBaseOptions,\n DensityContourLayerEvents,\n DensityContourLayerState,\n} from './types';\n\nexport const DENSITY_CONTOUR_BASE_DEFAULTS = {\n bandwidth: 20,\n thresholds: 10 as number | number[],\n cellSize: 4,\n padding: 50,\n recompute: 'auto' as 'auto' | 'manual',\n recomputeDebounceMs: 120,\n} as const;\n\nexport abstract class DensityContourLayerBase<\n TOpt extends DensityContourLayerBaseOptions,\n TEvt extends DensityContourLayerEvents = DensityContourLayerEvents,\n> extends WorldLayer<TOpt, DensityContourLayerState, TEvt, never, WorldLayerHit> {\n private readonly graphLayerId: string;\n\n private graph: GraphLayer | null = null;\n protected gfx: Graphics | null = null;\n private readonly subs: Array<() => void> = [];\n\n // Browser `setTimeout` returns `number`; using `ReturnType<typeof setTimeout>`\n // would resolve to NodeJS.Timeout in dual-typed environments and break the\n // `window.clearTimeout(...)` call site.\n private debounceTimer: number | null = null;\n\n constructor(opts: LayerOptions<TOpt>) {\n super({\n ...opts,\n // Density bands extend past node centres by `bandwidth + padding`, so\n // viewport culling against the bare node AABB would clip them.\n cullable: opts.cullable ?? false,\n // Passive overlay — clicks fall through to the graph below.\n hittable: opts.hittable ?? false,\n });\n this.graphLayerId = opts.options.graphLayerId;\n }\n\n protected createState(): DensityContourLayerState {\n return {};\n }\n\n protected override onMount(ctx: CanvasContext): void {\n const graph = ctx.layers.get<GraphLayer>(this.graphLayerId);\n if (!graph) {\n throw new Error(\n `${this.constructor.name} \"${this.id}\": graph layer \"${this.graphLayerId}\" not found. ` +\n `Add the GraphLayer before this contour layer.`,\n );\n }\n this.graph = graph;\n this.gfx = this.createGraphics('density-bands');\n\n const recompute = this.options.recompute ?? DENSITY_CONTOUR_BASE_DEFAULTS.recompute;\n if (recompute === 'auto') {\n this.subs.push(graph.events.on('data:changed', () => this.scheduleRecompute()));\n }\n\n // Initial paint — the graph may already hold data when we mount.\n this.scheduleRecompute();\n }\n\n protected override onUnmount(): void {\n for (const off of this.subs) off();\n this.subs.length = 0;\n if (this.debounceTimer !== null) {\n window.clearTimeout(this.debounceTimer);\n this.debounceTimer = null;\n }\n this.gfx = null;\n this.graph = null;\n }\n\n /**\n * Force an immediate recompute. Useful in `recompute: 'manual'` mode, or\n * to refresh the overlay after externally mutating options that don't\n * have setters yet.\n */\n recompute(): void {\n this.computeAndPaint();\n }\n\n hitTest(_worldX: number, _worldY: number): WorldLayerHit | null {\n return null;\n }\n\n // ─── Internals ─────────────────────────────────────────────────────────────\n\n private scheduleRecompute(): void {\n if (this.debounceTimer !== null) window.clearTimeout(this.debounceTimer);\n const wait =\n this.options.recomputeDebounceMs ?? DENSITY_CONTOUR_BASE_DEFAULTS.recomputeDebounceMs;\n this.debounceTimer = window.setTimeout(() => {\n this.debounceTimer = null;\n this.computeAndPaint();\n }, wait);\n }\n\n private computeAndPaint(): void {\n const g = this.gfx;\n const graph = this.graph;\n if (!g || !graph) return;\n\n const t0 = performance.now();\n\n // Collect node positions in world coords. d3-contour wants its grid in\n // a local positive-quadrant space, so we offset by (minX, minY) before\n // feeding points in and add the offset back when painting.\n const points: Array<{ x: number; y: number }> = [];\n for (const node of graph.store.nodes()) {\n const p = node.position;\n if (!p) continue;\n points.push({ x: p.x, y: p.y });\n }\n\n g.clear();\n\n if (points.length === 0) return;\n\n const pad = this.options.padding ?? DENSITY_CONTOUR_BASE_DEFAULTS.padding;\n let minX = Infinity,\n minY = Infinity,\n maxX = -Infinity,\n maxY = -Infinity;\n for (const p of points) {\n if (p.x < minX) minX = p.x;\n if (p.y < minY) minY = p.y;\n if (p.x > maxX) maxX = p.x;\n if (p.y > maxY) maxY = p.y;\n }\n minX -= pad;\n minY -= pad;\n maxX += pad;\n maxY += pad;\n const width = Math.max(1, Math.ceil(maxX - minX));\n const height = Math.max(1, Math.ceil(maxY - minY));\n\n const density: ContourMultiPolygon[] = contourDensity<{ x: number; y: number }>()\n .x((d) => d.x - minX)\n .y((d) => d.y - minY)\n .size([width, height])\n .bandwidth(this.options.bandwidth ?? DENSITY_CONTOUR_BASE_DEFAULTS.bandwidth)\n .thresholds(this.options.thresholds ?? DENSITY_CONTOUR_BASE_DEFAULTS.thresholds)\n .cellSize(this.options.cellSize ?? DENSITY_CONTOUR_BASE_DEFAULTS.cellSize)(points);\n\n this.paintDensity(g, density, minX, minY);\n\n // `recompute` is part of the base event contract — subclass event maps\n // must extend `DensityContourLayerEvents`, so this emit is always\n // type-correct. The cast bridges the generic TEvt to the literal\n // event name.\n (this.events.emit as (k: 'recompute', p: DensityContourLayerEvents['recompute']) => void)(\n 'recompute',\n {\n thresholds: density.length,\n points: points.length,\n durationMs: performance.now() - t0,\n },\n );\n }\n\n /**\n * Render the iso-bands into `g`. The bands are ordered low-density →\n * high-density; subclasses typically paint in that order so denser bands\n * sit on top. `offsetX`/`offsetY` are the world-space origin of the\n * compute grid — add them to each polygon point.\n */\n protected abstract paintDensity(\n g: Graphics,\n density: ContourMultiPolygon[],\n offsetX: number,\n offsetY: number,\n ): void;\n}\n","/**\n * Built-in colour ramps for {@link DensityContourLayer}.\n *\n * Each palette is an ordered array of `0xRRGGBB` stops from low-density to\n * high-density. The layer interpolates between adjacent stops so any band\n * count (3, 10, 30...) lands on a perceptually-smooth colour.\n *\n * Sequential single-hue palettes (`blues`, `greens`, ...) are drawn from\n * ColorBrewer; perceptual ramps (`viridis`, `plasma`, `magma`, `inferno`)\n * are 10-stop quantizations of matplotlib's perceptual colour maps. `warm`\n * and `cool` are ColorBrewer YlOrRd / BuPu equivalents.\n */\n\nexport type DensityContourPaletteName =\n | 'blues'\n | 'greens'\n | 'oranges'\n | 'purples'\n | 'reds'\n | 'viridis'\n | 'plasma'\n | 'magma'\n | 'inferno'\n | 'warm'\n | 'cool';\n\nexport const DENSITY_CONTOUR_PALETTES: Record<DensityContourPaletteName, number[]> = {\n blues: [\n 0xf7fbff, 0xdeebf7, 0xc6dbef, 0x9ecae1, 0x6baed6, 0x4292c6, 0x2171b5, 0x08519c, 0x08306b,\n ],\n greens: [\n 0xf7fcf5, 0xe5f5e0, 0xc7e9c0, 0xa1d99b, 0x74c476, 0x41ab5d, 0x238b45, 0x006d2c, 0x00441b,\n ],\n oranges: [\n 0xfff5eb, 0xfee6ce, 0xfdd0a2, 0xfdae6b, 0xfd8d3c, 0xf16913, 0xd94801, 0xa63603, 0x7f2704,\n ],\n purples: [\n 0xfcfbfd, 0xefedf5, 0xdadaeb, 0xbcbddc, 0x9e9ac8, 0x807dba, 0x6a51a3, 0x54278f, 0x3f007d,\n ],\n reds: [\n 0xfff5f0, 0xfee0d2, 0xfcbba1, 0xfc9272, 0xfb6a4a, 0xef3b2c, 0xcb181d, 0xa50f15, 0x67000d,\n ],\n viridis: [\n 0x440154, 0x482878, 0x3e4989, 0x31688e, 0x26828e, 0x1f9e89, 0x35b779, 0x6ece58, 0xb5de2b,\n 0xfde725,\n ],\n plasma: [\n 0x0d0887, 0x46039f, 0x7201a8, 0x9c179e, 0xbd3786, 0xd8576b, 0xed7953, 0xfa9e3b, 0xfdca26,\n 0xf0f921,\n ],\n magma: [\n 0x000004, 0x180f3d, 0x440f76, 0x721f81, 0x9e2f7f, 0xcd4071, 0xf1605d, 0xfd9668, 0xfeca8d,\n 0xfcfdbf,\n ],\n inferno: [\n 0x000004, 0x1b0c41, 0x4a0c6b, 0x781c6d, 0xa52c60, 0xcf4446, 0xed6925, 0xfb9a06, 0xf7d13d,\n 0xfcffa4,\n ],\n warm: [0xffeda0, 0xfed976, 0xfeb24c, 0xfd8d3c, 0xfc4e2a, 0xe31a1c, 0xb10026],\n cool: [0xe0ecf4, 0xbfd3e6, 0x9ebcda, 0x8c96c6, 0x8c6bb1, 0x88419d, 0x6e016b],\n};\n\n/** All built-in palette names in declaration order. Useful for GUI menus. */\nexport const DENSITY_CONTOUR_PALETTE_NAMES: readonly DensityContourPaletteName[] = Object.keys(\n DENSITY_CONTOUR_PALETTES,\n) as DensityContourPaletteName[];\n\n/**\n * Linear interpolation between two `0xRRGGBB` colours in sRGB space.\n * `t` is clamped to `[0, 1]`. sRGB-linear is \"good enough\" for adjacent\n * stops in a smooth ramp; for perceptually-uniform mixing across distant\n * hues, supply a function via `paletteFn`.\n */\nexport function lerpColor(a: number, b: number, t: number): number {\n const u = t <= 0 ? 0 : t >= 1 ? 1 : t;\n const ar = (a >> 16) & 0xff;\n const ag = (a >> 8) & 0xff;\n const ab = a & 0xff;\n const br = (b >> 16) & 0xff;\n const bg = (b >> 8) & 0xff;\n const bb = b & 0xff;\n const r = Math.round(ar + (br - ar) * u);\n const g = Math.round(ag + (bg - ag) * u);\n const bl = Math.round(ab + (bb - ab) * u);\n return (r << 16) | (g << 8) | bl;\n}\n\n/**\n * Linearly interpolate a `0xRRGGBB` colour from a stop array based on the\n * band's position `(index / (total - 1))`. Returns the last stop if there's\n * only one band or one stop.\n */\nexport function sampleStops(stops: number[], index: number, total: number): number {\n if (stops.length === 0) return 0x000000;\n if (total <= 1 || stops.length === 1) return stops[stops.length - 1]!;\n const t = index / (total - 1);\n const pos = Math.max(0, Math.min(1, t)) * (stops.length - 1);\n const lo = Math.floor(pos);\n const hi = Math.min(stops.length - 1, lo + 1);\n return lerpColor(stops[lo]!, stops[hi]!, pos - lo);\n}\n","/**\n * `DensityContourFillLayer` — paints filled iso-bands from a\n * d3-contour density estimate over a source `GraphLayer`'s node positions.\n * No outline. For the stroked / Observable-style look, use\n * {@link DensityContourStrokeLayer}; compose both layers (same\n * `graphLayerId`, different `zIndex`) for fill + outline together.\n */\n\nimport type { ContourMultiPolygon } from 'd3-contour';\nimport type { Graphics } from 'pixi.js';\n\nimport { DensityContourLayerBase } from './DensityContourLayerBase';\nimport { DENSITY_CONTOUR_PALETTES, lerpColor, sampleStops } from './palettes';\nimport type { DensityContourFillLayerOptions } from './types';\n\nconst FILL_DEFAULTS = {\n fillOpacity: 0.4,\n palette: 'blues' as const,\n};\n\nfunction resolveStops(\n palette: DensityContourFillLayerOptions['palette'] | undefined,\n): number[] {\n if (Array.isArray(palette)) return palette;\n const name = palette ?? FILL_DEFAULTS.palette;\n return DENSITY_CONTOUR_PALETTES[name] ?? DENSITY_CONTOUR_PALETTES[FILL_DEFAULTS.palette];\n}\n\nexport class DensityContourFillLayer extends DensityContourLayerBase<DensityContourFillLayerOptions> {\n protected paintDensity(\n g: Graphics,\n density: ContourMultiPolygon[],\n offsetX: number,\n offsetY: number,\n ): void {\n const opacity = this.options.fillOpacity ?? FILL_DEFAULTS.fillOpacity;\n const total = density.length;\n const colorAt = this.resolveFillColor();\n\n // d3 returns bands low-density → high-density; paint in that order so\n // denser bands sit on top.\n density.forEach((band, i) => {\n const fillColor = colorAt(band.value, i, total);\n // Each band is a MultiPolygon: an array of polygons; each polygon is\n // an array of rings (outer + holes). For density bands the outer ring\n // is what we want filled; holes are rare and visually subtle, so we\n // paint the outer ring only (PixiJS `Graphics` doesn't expose ring\n // subtraction in v8's path builder).\n for (const polygon of band.coordinates) {\n const outer = polygon[0];\n if (!outer || outer.length < 3) continue;\n const flat: number[] = new Array(outer.length * 2);\n for (let k = 0; k < outer.length; k++) {\n const pt = outer[k]!;\n flat[k * 2] = (pt[0] ?? 0) + offsetX;\n flat[k * 2 + 1] = (pt[1] ?? 0) + offsetY;\n }\n g.poly(flat);\n }\n g.fill({ color: fillColor, alpha: opacity });\n });\n }\n\n /**\n * Resolve the palette chain into a per-band colour function. Order\n * (most specific wins): {@link DensityContourFillLayerOptions.fillColor}\n * > `paletteFn(t)` > `paletteRangeStart`/`paletteRangeEnd` (both set) >\n * `palette` > default `'blues'`.\n */\n private resolveFillColor(): (value: number, index: number, total: number) => number {\n const o = this.options;\n if (o.fillColor) return o.fillColor;\n if (o.paletteFn) {\n const fn = o.paletteFn;\n return (_v, i, n) => fn(n > 1 ? i / (n - 1) : 0);\n }\n if (o.paletteRangeStart !== undefined && o.paletteRangeEnd !== undefined) {\n const a = o.paletteRangeStart;\n const b = o.paletteRangeEnd;\n return (_v, i, n) => lerpColor(a, b, n > 1 ? i / (n - 1) : 0);\n }\n const stops = resolveStops(o.palette);\n return (_v, i, n) => sampleStops(stops, i, n);\n }\n}\n","/**\n * `DensityContourStrokeLayer` — paints stroked iso-lines from a\n * d3-contour density estimate over a source `GraphLayer`'s node positions.\n * No fill. Defaults reproduce Observable's\n * [`@d3/density-contours`](https://observablehq.com/@d3/density-contours):\n * steelblue strokes with the topographic \"index contour\" pattern (every 5th\n * band heavy at 1 unit, the rest hair-thin at 0.25).\n *\n * For filled iso-bands use {@link DensityContourFillLayer}; compose both\n * layers (same `graphLayerId`, different `zIndex`) for fill + outline\n * together.\n */\n\nimport type { ContourMultiPolygon } from 'd3-contour';\nimport type { Graphics } from 'pixi.js';\n\nimport { DensityContourLayerBase } from './DensityContourLayerBase';\nimport { DENSITY_CONTOUR_PALETTES, lerpColor, sampleStops } from './palettes';\nimport type { DensityContourStrokeLayerOptions } from './types';\n\nconst STROKE_DEFAULTS = {\n strokeColor: 0x4682b4, // steelblue — Observable's default\n strokeWidth: 0.5,\n palette: 'blues' as const,\n};\n\nfunction resolveStops(\n palette: DensityContourStrokeLayerOptions['palette'] | undefined,\n): number[] {\n if (Array.isArray(palette)) return palette;\n const name = palette ?? STROKE_DEFAULTS.palette;\n return DENSITY_CONTOUR_PALETTES[name] ?? DENSITY_CONTOUR_PALETTES[STROKE_DEFAULTS.palette];\n}\n\nexport class DensityContourStrokeLayer extends DensityContourLayerBase<DensityContourStrokeLayerOptions> {\n protected paintDensity(\n g: Graphics,\n density: ContourMultiPolygon[],\n offsetX: number,\n offsetY: number,\n ): void {\n const total = density.length;\n const widthAt = this.resolveWidth();\n const strokeAt = this.resolveStrokeColor();\n\n density.forEach((band, i) => {\n const w = widthAt(i, total, band.value);\n if (w <= 0) return; // skip; nothing to paint for this band\n\n for (const polygon of band.coordinates) {\n const outer = polygon[0];\n if (!outer || outer.length < 3) continue;\n const flat: number[] = new Array(outer.length * 2);\n for (let k = 0; k < outer.length; k++) {\n const pt = outer[k]!;\n flat[k * 2] = (pt[0] ?? 0) + offsetX;\n flat[k * 2 + 1] = (pt[1] ?? 0) + offsetY;\n }\n g.poly(flat);\n }\n g.stroke({ color: strokeAt(band.value, i, total), width: w });\n });\n }\n\n /**\n * Resolve the per-band stroke-width function. Precedence:\n * 1. `strokeWidth` is a function → use it directly.\n * 2. All three index-contour sugar fields set → build\n * `(i) => i % every === 0 ? major : minor`.\n * 3. `strokeWidth` is a number → constant.\n * 4. Default {@link STROKE_DEFAULTS.strokeWidth}.\n */\n private resolveWidth(): (index: number, total: number, value: number) => number {\n const o = this.options;\n if (typeof o.strokeWidth === 'function') return o.strokeWidth;\n\n if (\n o.indexEvery !== undefined &&\n o.indexMajorWidth !== undefined &&\n o.indexMinorWidth !== undefined\n ) {\n const every = o.indexEvery;\n const major = o.indexMajorWidth;\n const minor = o.indexMinorWidth;\n return (i) => (i % every === 0 ? major : minor);\n }\n\n const w = typeof o.strokeWidth === 'number' ? o.strokeWidth : STROKE_DEFAULTS.strokeWidth;\n return () => w;\n }\n\n /**\n * Resolve the per-band stroke-colour function. When `strokeColor` is\n * `'palette'`, walk the palette chain (`paletteFn` > range > `palette`);\n * otherwise return a constant colour function. Default is steelblue.\n */\n private resolveStrokeColor(): (value: number, index: number, total: number) => number {\n const o = this.options;\n const sc = o.strokeColor;\n\n if (sc === 'palette') {\n if (o.paletteFn) {\n const fn = o.paletteFn;\n return (_v, i, n) => fn(n > 1 ? i / (n - 1) : 0);\n }\n if (o.paletteRangeStart !== undefined && o.paletteRangeEnd !== undefined) {\n const a = o.paletteRangeStart;\n const b = o.paletteRangeEnd;\n return (_v, i, n) => lerpColor(a, b, n > 1 ? i / (n - 1) : 0);\n }\n const stops = resolveStops(o.palette);\n return (_v, i, n) => sampleStops(stops, i, n);\n }\n\n const c = typeof sc === 'number' ? sc : STROKE_DEFAULTS.strokeColor;\n return () => c;\n }\n}\n"]}

package/package.json ADDED Viewed

@@ -0,0 +1,61 @@
+{
+  "name": "@invana/graph-layer-d3-contour",
+  "version": "0.0.1",
+  "description": "Density-contour overlay Layer for @invana/graph, backed by d3-contour.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typedocOptions": {
+    "entryPoints": [
+      "src/index.ts"
+    ]
+  },
+  "dependencies": {
+    "d3-contour": "^4.0.2"
+  },
+  "peerDependencies": {
+    "pixi.js": "^8.18.1",
+    "@invana/canvas": "0.0.1",
+    "@invana/graph": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/d3-contour": "^3.0.6",
+    "pixi.js": "^8.18.1",
+    "tsup": "^8.3.5",
+    "typescript": "5.9.2",
+    "@invana/canvas": "0.0.1",
+    "@invana/graph": "0.0.1",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "keywords": [
+    "canvas",
+    "graph",
+    "layer",
+    "d3",
+    "d3-contour",
+    "density",
+    "contour"
+  ],
+  "license": "Apache-2.0",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src/",
+    "check-types": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}