gjonor

@gjonor·23 public vizzes

[Test]

A world map renders country boundaries from a remote GeoJSON file using d3.geoMercator and d3.geoPath. The map scales to its container’s dimensions, with countries drawn as SVG paths on a light background. React hooks manage fetching and state, while SVG styling fills the viewport.

Feb 27, 2020

Loading thumbnail…

[Test]

A gauge chart displays a two-segment proportional breakdown, with values that can be adjusted via buttons or a drag-to-resize control. The semi-circular arc uses d3.pie and d3.arc, animating transitions with transition.attrTween and interpolate. A separate bar chart, rendered with SVG and d3.scaleBand, updates its height and color scale on data changes, using a ResizeObserver hook for responsive dimensions. Both components react to state updates, with d3.v5 driving the SVG rendering and React hooks managing lifecycle.

Feb 24, 2020

Loading thumbnail…

[07] Gauge Chart - Using React Hooks with D3

A gauge chart shows a single dynamic value as a two-part donut arc, with the current proportion displayed as a text label. The chart responds to controls that adjust, filter, or append to the data array. The code uses React hooks (`useRef`, `useEffect`) to manage the D3.js SVG rendering, with D3's `arc` and `pie` functions calculating the arc paths. Animated updates are handled via `transition.attrTween`, interpolating between previous and new arc data. The `d3.drag` API allows the user to horizontally drag a button to resize the container, triggering the gauge to update reactively.

Feb 23, 2020

Loading thumbnail…

[06] Responsive Chart Components with ResizeObserver - Using React Hooks with D3

A bar chart demonstrates responsive sizing with React and D3, using a custom `useDimensions` hook with `ResizeObserver` to track container dimensions. The component re-renders axes and bars whenever the wrapper resizes, computing `scaleBand` and `scaleLinear` scales from the observed width and height. Interactive buttons adjust, filter, or append data, while the chart animates transitions via D3's `transition` method. A draggable button resizes the container, triggering the observer. Styling uses inline SVG with CSS transforms, and tooltips appear on hover with `mouseenter` events.

Feb 22, 2020

Loading thumbnail…

[05] Interactivity - Using React Hooks with D3

This interactive bar chart demonstrates how React hooks and D3 v5 work together to create a dynamic, animated visualization. The example uses `useState` and `useEffect` to manage a mutable data array, while D3's `scaleBand`, `scaleLinear`, and `join` method handle the rendering of SVG bars and tooltips. On mouseenter, a tooltip text element appears with data binding, positioned using the band scale’s index value, and animates its opacity and y-position via `transition()`. Buttons trigger data updates—increment, decrement, filter, or append—which re-render the chart through the React state change. The code also demonstrates axis generation with `axisBottom` and `axisRight`, applying a color scale to bar fills based on value.

Feb 22, 2020

Loading thumbnail…

[02] Curved Line Chart - Using React Hooks with D3

This example demonstrates a curved line chart rendered as an SVG, where a dataset of numeric values is mapped to a path using D3’s `line` generator with the `curveCardinal` interpolation. The chart initializes with twenty points, and two buttons trigger updates: one increases every value by 5, while the other filters out values below 35, causing the line to redraw dynamically. React hooks (`useRef`, `useEffect`, `useState`) manage the SVG element and data state, while D3’s `select` and `path` joins handle the visual update. The viewport is set to 940 by 450 pixels, with a yellow fill and blue stroke.

Feb 22, 2020

Loading thumbnail…

[04] Animated bar chart - Using React Hooks with D3

This example shows an interactive animated bar chart where users can increment, decrement, filter, or append values to a dataset, with bars flipping vertically and transitioning smoothly to new heights. Built with React Hooks and D3 v5, it uses `scaleBand` for the categorical x-axis, `scaleLinear` for y and color interpolation, and `selection.transition()` to animate bar heights and fill colors based on a clamped color scale. The SVG rendering uses `transform: scale(1, -1)` to flip bars, with axes positioned via `axisBottom` and `axisRight`.

Feb 22, 2020

Loading thumbnail…

[03] Axes and scales - Using React Hooks with D3

This example shows a line chart of an array of numeric values rendered as a smooth, cardinal-curved path with labeled axes. The code uses React Hooks with `useState` and `useRef` to manage data and the SVG element, while D3 v5’s `scaleLinear`, `axisBottom`, `axisRight`, and `line` with `curveCardinal` construct the visualization. Buttons update or filter the data, triggering a re-render that redraws the line and axes against a fixed 900×400 SVG viewport.

Feb 22, 2020

Loading thumbnail…

[01] The Basics - Using React Hooks with D3

This example demonstrates how to combine React Hooks with D3 to render and update a simple SVG scatterplot. A `useState` hook manages an array of numeric data, while a `useRef` hook and `useEffect` hook initialize an SVG canvas using `d3.select` from D3 v5. Circles are appended via `selectAll(...).data(...).join('circle')`, with radius and position derived from each value. Clicking the “Update” button increments the data by 5, and “Filter” removes values over 35, triggering a re-render through React’s state changes.

Feb 22, 2020

Loading thumbnail…

React Starter

This React Starter example demonstrates how to resize an SVG element by adjusting a wrapper div's dimensions through button clicks. The application uses React's `useState` and `useRef` hooks alongside D3's `select` to read and update CSS width values dynamically. A `d3.select` call retrieves the element's current width, which increments or decrements by 50 pixels with each button press. The rendered SVG fills the container with a light gray background, showing a minimal integration of React state management with D3 utilities for DOM manipulation and styling.

Feb 21, 2020

Loading thumbnail…

React Starter

This example demonstrates how to integrate React with D3 by building a resizable SVG container. A draggable div wrapper, observed via ResizeObserver, updates the SVG’s width and height state through a custom React hook (useState, useEffect) and D3’s drag behavior. The visualization shows the interplay between React’s declarative rendering and D3’s imperative event handling. It uses React 16, ReactDOM, d3.select, d3.drag, and d3.event to log and apply dynamic size changes.

Feb 20, 2020

Loading thumbnail…

D3 drag test

This example demonstrates a draggable splitter that resizes two adjacent panes in a web layout. Using D3 v5’s `drag` behavior, dragging the central divider horizontally triggers `event.x` to update each pane’s inline width and reposition the splitter via `setOffset`. The panes hold static text, with dimensions computed from the container’s current pixel width. The implementation uses `select`, `selectAll`, and `style` from D3, plus React for overall structure, and plain CSS for layout and hover cursor styling.

Feb 20, 2020

Loading thumbnail…

Styled-Components example

Styled-Components example shows how CSS-in-JS embeds styling directly within React component definitions, rendering a title, buttons, and a wrapper using styled.h1, styled.section, and styled.button. It demonstrates prop-based styling via interpolations in template literals, where a primary prop adapts button colors, and component extension through styled(Button) overrides. The code imports React, ReactDOM, and styled-components, then renders the composed UI into the #root div.

Feb 18, 2020

Loading thumbnail…

Selection list with group filter

A horizontal bar chart displays the top economies by GDP, filterable by World Bank country classifications through a select dropdown. The selection list, populated from a TSV file using d3.tsv and d3.nest, groups countries by codes like “Arab World” and “Euro area.” React state updates the chart data, and d3.scaleBand, d3.scaleLinear, d3.axisLeft, and d3.axisBottom render the SVG bars and axes, with GDP values from World Bank data shown in current U.S. dollars.

Feb 16, 2020

Loading thumbnail…

Multiple files with ES6 modules

This example displays a horizontal bar chart of World Bank population data for 31 countries, using the most recent year with available values. The React-based application loads the CSV data through a custom ES6 module that parses and filters the multi-row metadata headers. D3 v5’s `scaleBand` and `scaleLinear` map the country names and population values to SVG rectangles, while `axisLeft` and `axisBottom` render the axes. The chart demonstrates a modular architecture separating data loading, utility functions, and the bar chart component.

Feb 15, 2020

Loading thumbnail…

React D3 CSV BarChart

A React bar chart displays the nominal GDP in US dollars for 31 countries, using the latest available yearly data from the World Bank's World Development Indicators. The chart renders as an SVG with linear and band scales, using D3 v5 functions such as `scaleLinear`, `scaleBand`, `axisBottom`, and `axisLeft` to position bars and axes. Data is loaded from CSV files and parsed with D3's `text` and `csvParse` methods, then filtered and sorted within React hooks.

Feb 5, 2020

Loading thumbnail…

D3 and React

Two React components render D3 visualizations side-by-side. A bar chart maps an array of values to SVG rectangles and text labels, using D3's data join with `selectAll`, `enter`, and attribute setters, with colors via HSL strings and classes for high/low values. A second component demonstrates React's managed rendering alongside unmanaged D3 updates, appending HTML elements, merging enter/update selections, and animating appended spans with `transition().duration().delay()`. Both components use `useRef` and `useEffect` to access the DOM, with data generated by `d3.range`.

Feb 2, 2020

Loading thumbnail…

D3 and React Hooks

Two pie charts render identical datasets side by side, each taking a different approach to integrating D3 with React function components. The first, PieSVG, lets React fully manage the SVG lifecycle, mapping data arcs to JSX elements. The second, PieHooks, uses `useEffect` and `useRef` to imperatively manipulate the DOM with D3 selections like `selectAll`, `enter`, and `merge`. Both use `d3.pie`, `d3.arc`, and `d3.scaleOrdinal` to generate and style the arcs, with random data regenerated on button click.

Feb 1, 2020

Loading thumbnail…

Smiley Face Part II (fork)

A smiling face rendered in SVG with React and D3. The face features a silver circle, black eyes, and a mouth arc drawn with `d3.arc`. Nine rectangular teeth are placed around the mouth using a reusable `Tooth` component that rotates each tooth via a `transform` attribute. The code demonstrates how React components can encapsulate repeated SVG elements, replacing commented-out manual markup with a `Tooth` function that accepts a rotation prop. The example uses React 16.9 and D3 v5.

Jan 30, 2020

Loading thumbnail…

Face part IV, React components

A smiling face built from SVG shapes renders in React, using d3.arc to generate the mouth path and custom React components for the background circle, eyes, and mouth. The code imports React, ReactDOM, and d3’s arc function, applies CSS filters and a linear gradient via SVG defs, and positions elements with transforms. The face is drawn with yellow and red gradients, black strokes, and dropshadows, demonstrating modular component reuse and d3 integration within a React rendering pipeline.

Jan 25, 2020

Loading thumbnail…

Face part III, React + D3

This example renders a stylized smiling face using React and D3.js. The face is composed of SVG circles for the head, eyes, and pupils, all positioned with hard-coded coordinates. The mouth is generated as an SVG path using D3’s `arc` generator, which creates a partial ring with specified inner and outer radii and angles. The React app uses `ReactDOM.render` to mount the SVG into the document, while the `d3` namespace provides the arc path data.

Jan 25, 2020

Loading thumbnail…

React Emoticon

A yellow smiley face is rendered as a scalable vector graphic, centered within a 960 by 500 pixel viewport. The face is constructed from SVG circles, including a large yellow head with a black stroke, two white eyes with dark pupils, and a simple black mouth. The React application uses `ReactDOM.render` to mount the component, which directly defines the SVG elements using JSX. All facial features are positioned relative to the center using defined offset constants, and the code relies on React's conditional logic solely through static `props` and inline styling.

Jan 25, 2020

Loading thumbnail…

Emoticon

A smiling face emoticon is drawn as an SVG graphic, centered on a yellow circle with black outlines, white eyes, and a simple mouth. The visualization uses React to render static SVG elements directly in the DOM, with the face constructed from basic geometric shapes: circles for the head, eyes, and mouth. The styling is minimal, relying on inline SVG attributes and CSS for layout, and the data source is implicit in the hand-coded markup rather than fetched externally.

Jan 20, 2020