Skip to main content
100%

Using Pym.js for responsive d3

✓ Published0🌍 Public
Aalansmithy
Last edited Apr 15, 2015
Created on Apr 14, 2015

This example demonstrates how Pym.js enables responsive SVG graphics by redrawing d3 content based on iframe width. The embedded page uses a `pym.Child` with a `renderCallback` to trigger `createChart`, which swaps between a landscape scene with trees and a portrait figure at a 600-pixel breakpoint. The code applies d3.v3 selections, `append`, `attr`, and `use` elements with `xlink:href` references to symbol definitions. It also uses Pym.js’s parent–child messaging to update the graphic on window resize, as shown in the parent `index.html` and child `svgimage.html` files.

AI-generated description

Pym.js

Pym.js by NPR is a really useful tool for deploying responsive SVG graphics.

Pym.js works by creating dynamic iframes on a (parent) page which can transmit window-size changes to an embedded (child) page. The child can also send changes back to the parent if interaction causes the embedded item to change in height. Crucially, the child page can be set to redraw its content when a window is resized, allowing different content to be generated depending on the size of the iframe.

This playful (and artistically inept) example illustrates the concept by using d3 to draw different images (a 'landscape' landscape and a 'portrait' portrait) depending on the window width. To see it properly using bl.ocks.org, you'll need to launch into the new window view - then just resize the window by dragging the window in and out (the switch happens at 600px).

You can read more about using pym.js on the NPR Blog

You can see data visualisation examples using this approach on Visual.ONS

Similar vizzes

Loading thumbnail…

Responsive Starter Code

This responsive starter code demonstrates how to build a D3 visualization that adapts to the browser window’s dimensions. It renders a full-screen SVG containing a single rounded rectangle that resizes along with the viewport. The example uses D3 v5 with a reusable component function, `myResponsiveComponent`, which receives width and height from `document.body.clientWidth` and `document.body.clientHeight`. A resize event listener triggers the `render` function, updating the SVG and rectangle attributes via D3’s data-join and merge pattern, ensuring smooth, unobtrusive resizing without redeclaring elements.

JJasmine Ye Han
70% match
Loading thumbnail…

Fork of Fork of Responding to Resize

This example demonstrates a simple responsive chart that dynamically adjusts an SVG to fill the browser viewport. It first extracts the client width and height from its container, then sets the SVG’s `width` and `height` attributes accordingly, and redraws two green diagonal lines to verify the resizing behavior. The visualization uses D3.js v5 to create and update the SVG elements, leveraging a listener for the window’s `resize` event to trigger the redraw. The code relies on the `d3.select` API to bind the chart container and `attr` to update the SVG dimensions.

Ccharliemok
70% match
Loading thumbnail…

Responsive Axes

This example demonstrates a reusable chart component that adapts to the full browser viewport, redrawing itself on window resize. It applies the D3.js margin convention to separate the plotting area from axis labels, using `d3.scaleLinear` and `d3.axisLeft`/`d3.axisBottom` to render axes. A rounded rectangle fills the inner chart space, while an event listener triggers the render function to recompute dimensions on every resize.

JJasmine Ye Han
69% match
Loading thumbnail…

Fork of Responding to Resize

This example demonstrates a responsive SVG visualization that draws a green X spanning the full browser window. The chart container fills the page via CSS, and a `redraw()` function extracts the container’s `clientWidth` and `clientHeight` to set the SVG’s dimensions and position its two lines. Using D3 v5’s selection API (`d3.select`, `.append`, `.merge`), the code updates line coordinates and stroke properties on every window `resize` event, ensuring the graphic always matches the viewport.

CCristina Macaraig
69% match
Loading thumbnail…

Fork of Responding to Resize

This example demonstrates a responsive SVG visualization that fills the entire browser window and redraws its content whenever the viewport size changes. It shows two thick, semi-transparent green lines forming an X across the full width and height of the chart container. The code uses D3 v5 to select the `#chart` div, append an SVG element, and bind line data to render the X. A `redraw` function reads the container’s `clientWidth` and `clientHeight` to update the SVG’s dimensions, then repositions the lines via the `merge` pattern. The `window.addEventListener("resize", redraw)` triggers this responsive behavior.

Hhamza.miftah@gmail.com
69% match
Loading thumbnail…

Responsive Axes

This example demonstrates how a D3 chart can remain responsive as the browser window resizes, with the axes and tick density adjusting dynamically. The visualization uses D3 v5 with an SVG rendering approach, explicitly calling `d3.axisBottom` and `d3.axisLeft` in conjunction with `d3.scaleLinear`. The code listens for the window `resize` event and re-renders the axes, recalculating tick counts based on the available `innerWidth` and `innerHeight` using a custom `marginConvention` helper. The chart displays a simple empty rectangular plot area with labeled X and Y axes.

AAjayyy
69% match
Loading thumbnail…

Fork of Responding to Resize

This example demonstrates a responsive D3.js visualization that draws a simple teal X across an SVG canvas. The chart container fills the entire browser window using CSS positioning, and the `redraw()` function dynamically extracts the container’s client width and height on every resize event. The code then sets the SVG’s dimensions accordingly and uses D3’s data join to update two line elements, ensuring the X always stretches corner-to-corner. The visualization relies on `d3.select`, `attr`, and the window’s `resize` listener, with all rendering performed via SVG line elements.

Ppangaotata
69% match
Loading thumbnail…

Fork of Responding to Resize

This example demonstrates how to create a D3.js visualization that responds to browser resizing. The code uses the `d3.select` API to append an SVG element to a fixed-position `#chart` div. On every resize event, the `redraw` function extracts the calculated `clientWidth` and `clientHeight` from the container, then adjusts the SVG's attributes and re-renders two intersecting lines into a green X mark. This approach uses CSS for layout sizing while relying on JavaScript event handling and the `merge` API for simple data updates.

Ggiulius540
68% match