@amcharts/amcharts5-mcp 1.5.0 → 1.6.0

package/extended/charts/map-chart/map-polygon-series.md

@@ -378,6 +378,53 @@ polygonSeries.mapPolygons.template.events.on("click", function(ev) {
   }
 });
 
+### Linking via `urlField` (5.20.7)
+
+Since 5.20.7 a click handler is not needed: set series' `urlField` to the data field holding the URL, and clicking a polygon that has one opens it. `linkTarget` sets where it opens.
+
+```javascript
+var polygonSeries = chart.series.push(
+  am5map.MapPolygonSeries.new(root, {
+    geoJSON: am5geodata_worldLow,
+    urlField: "url",
+    linkTarget: "_blank"
+  })
+);
+
+polygonSeries.data.setAll([{
+  id: "US",
+  url: "https://en.wikipedia.org/wiki/United_States"
+}, {
+  id: "CA",
+  url: "https://en.wikipedia.org/wiki/Canada"
+}, {
+  id: "MX",
+  url: "https://en.wikipedia.org/wiki/Mexico"
+}]);
+```
+
+Setting
+
+Default
+
+Comment
+
+`urlField`
+
+(none)
+
+A data field holding the URL to open when the data item's element is clicked. Links are off until this is set.
+
+`linkTarget`
+
+`"_self"`
+
+Where the URL opens: `"_self"` (same window, like a plain link), `"_blank"` (new tab, opened with `noopener`), or a named window/frame. A chart embedded in an iframe usually wants `"_blank"` or `"_top"`.
+
+Polygons with a URL get a pointer cursor automatically, unless you set a `cursorOverStyle` yourself. `urlField` can be set after the data, and a URL added to an item later (e.g. via `data.setIndex()`) links too. Script URLs (`javascript:`, `data:`, `vbscript:`) are not opened. To intercept links (e.g. in an editor), override the series' `openUrl(dataItem)` method.
+
+The same settings work on other series: they link bullets of any series, columns (including candlesticks, OHLC and Gantt bars), pie/funnel/pyramid/pictorial slices, Venn slices, and map lines. Hierarchy nodes, flow nodes and links, word cloud words and map Sankey nodes are not linked — use a click handler for those.
+
 ## Excluding or including polygons
 
 Series can be set up to either exclude certain polygons out of the loaded geodata, or only include specific ones.

package/extended/charts/xy-chart/axes/category-axis.md

@@ -60,6 +60,8 @@ Or it can be a subset of data.
 
 IMPORTANTThe order of categories needs to be the same in both series' and axis' data.
 
+NOTE Since 5.20.6, series items are drawn even when the series' data is not in the same order as the axis categories — for example, a Gantt-like column chart where several items share a category and the data is sorted by date. (Before, some of those items were not drawn at all.) A line series, however, still connects its points in data order, so for lines keep the series data in category order.
+
 Having different data for category axis makes sense in the situations where we want to have only specific categories displayed:
 
 let xAxis = chart.xAxes.push(

package/extended/concepts/animations.md

@@ -102,6 +102,124 @@ handDataItem.animate({
 });
 
 
+## Declarative animations (`animations` setting)
+
+Since 5.20.8 every element has an `animations` setting: a list of animations described as data instead of started with `animate()`. Being a plain setting, it can be set like any other — on an element, a template, a bullet's sprite, or in a [JSON config](https://www.amcharts.com/docs/v5/concepts/serializing/) — and a [serialized](https://www.amcharts.com/docs/v5/concepts/serializing/chart-serializer/) chart keeps it.
+
+NOTE The typings (and API reference) mark `animations` as `@since 5.21.0`, but it shipped in 5.20.8.
+
+Each entry in the list is an object with these fields:
+
+Field
+
+Default
+
+Comment
+
+`key`
+
+(required)
+
+Setting to animate. With `target: "dataItem"`, a value of the element's data item.
+
+`from`
+
+current value
+
+Value to start from.
+
+`to`
+
+(required)
+
+Value to animate to.
+
+`duration`
+
+(required)
+
+Duration in milliseconds. With `yoyo`, it is the duration of one way, so a full there-and-back takes twice as long.
+
+`delay`
+
+`0`
+
+Milliseconds to wait before starting.
+
+`loops`
+
+`1`
+
+How many times to play the animation. `0` plays it forever (`Infinity` works too in JavaScript).
+
+`yoyo`
+
+`false`
+
+Go back to `from` after reaching `to`, rather than jumping back.
+
+`easing`
+
+`"linear"`
+
+Easing **by name**: `"linear"`, `"quad"`, `"cubic"`, `"exp"`, `"sine"`, `"circle"`, `"bounce"` or `"elastic"`. An unknown name silently falls back to linear. Functions are not accepted here.
+
+`ease`
+
+`"in"`
+
+Which way the easing applies: `"in"`, `"out"` or `"inOut"` — the same as wrapping the function in `am5.ease.out()` or `am5.ease.inOut()`.
+
+`target`
+
+`"self"`
+
+`"self"` animates a setting of the element; `"dataItem"` animates a value of the element's data item.
+
+The following makes each bullet pulse, for ever:
+
+```javascript
+series.bullets.push(function (root, series, dataItem) {
+  return am5.Bullet.new(root, {
+    sprite: am5.Circle.new(root, {
+      radius: 6,
+      animations: [
+        { key: "scale", from: 1, to: 1.6, duration: 800, loops: 0, yoyo: true, easing: "sine" },
+        { key: "opacity", from: 1, to: 0.3, duration: 800, loops: 0, yoyo: true }
+      ]
+    })
+  });
+});
+```
+
+The animations start when the setting is applied, restart when it changes (the settings they animated are put back to what they held first), and stop when the element is disposed.
+
+IMPORTANT With `from` omitted, the animation starts from the setting's current value. If that value is `undefined`, the element jumps straight to `to` and nothing animates. `scale`, `opacity` and `rotation` are fine (the theme gives them a value), but settings like `dx` or `fill`, or a data item value that is not set yet (e.g. a map point without `positionOnLine`), need an explicit `from`.
+
+With `target: "dataItem"`, the entry animates the data item the element belongs to — for example, a map point's `positionOnLine`, which flies the point along its line. See "[Map point series: Points on a line](https://www.amcharts.com/docs/v5/charts/map-chart/map-point-series/#Points_on_a_line)".
+
+In a JSON config, colors and percents in `from`/`to` are written in their object form:
+
+```json
+{
+  "type": "Circle",
+  "settings": {
+    "radius": 6,
+    "animations": [{
+      "key": "fill",
+      "from": { "type": "Color", "value": "#ff0000" },
+      "to": { "type": "Color", "value": "#0000ff" },
+      "duration": 1000,
+      "loops": 0,
+      "yoyo": true
+    }]
+  }
+}
+```
+
+A serialized chart keeps the values the animated settings were configured with, never ones caught mid-animation. `ChartSerializer` can also turn a never-ending animation started in code with `animate()` into an `animations` entry — see its `runningAnimations` setting in "[Chart serializer](https://www.amcharts.com/docs/v5/concepts/serializing/chart-serializer/)".
+
+
 ## Animating between states
 
 When element [state](https://www.amcharts.com/docs/v5/concepts/settings/states/) is applied, its values will replace current setting values.
@@ -328,12 +446,12 @@ Will overshoot end value, then bounce back a few times before settling down at t
 
 Constant speed during all duration.
 
-`am5.ease.pow`
-
 `am5.ease.quad`
 
 `am5.ease.sine`
 
+NOTE `am5.ease.pow` is not a ready-to-use easing: it is `pow(t, e)` and needs an exponent as its second parameter. Passed directly as `easing`, the exponent is `undefined` and the animation produces `NaN`. Wrap it in a function instead: `easing: function(t) { return am5.ease.pow(t, 3); }`.
+
 Below demo shows the behavior of various basic easing functions:
 
 
@@ -375,4 +493,20 @@ The basic easing function is applied at the end animation.
 
 Plays animation to the end value, then returns back to the starting value, using supplied basic function.
 
+### Easing functions by name (5.20.8)
+
+The eight basic easing functions listed above carry a name, which is what lets the [`animations` setting](#Declarative_animations_animations_setting) and JSON configs refer to them as strings.
+
+`am5.ease.byName(name, mode)` returns an easing function by its name — `"linear"`, `"quad"`, `"cubic"`, `"exp"`, `"sine"`, `"circle"`, `"bounce"` or `"elastic"` — optionally wrapped by `mode`: `"in"` (default), `"out"` or `"inOut"`. An unknown name gives `linear`.
+
+`am5.ease.easingInfo(easing)` does the opposite: it returns `{ easing, ease?, yoyo? }` describing a function, or `undefined` for one that cannot be named. Functions made with `out()`, `inOut()` and `yoyo()` keep the name of the function they wrap; a function of your own, a wrapped `pow`, or a combination like `out(yoyo(...))` has none.
+
+```javascript
+am5.ease.byName("cubic", "out");                     // same as am5.ease.out(am5.ease.cubic)
+am5.ease.easingInfo(am5.ease.yoyo(am5.ease.sine));   // { easing: "sine", yoyo: true }
+am5.ease.easingInfo(function(t) { return t * t; });  // undefined
+```
+
+NOTE The typings mark `byName()`, `easingInfo()` and `IEasingInfo` as `@since 5.21.0`, but they shipped in 5.20.8.
+
 

package/extended/concepts/data.md

@@ -773,6 +773,8 @@ am5.net.load("/data/mydata.csv").then(function(result) {
   console.log("Error loading " + result.xhr.responseURL);
 });
 
+NOTE Since 5.20.7, `CSVParser.parse()` copes with an empty string, such as an empty response from a server. Before, it looped until it ran out of memory and threw "Invalid array length". With `useColumnNames: true` an empty string now parses to an empty array (`[]`); without it, to a single empty row (`[{}]`) — check for an empty `result.response` before parsing if you need to tell the two apart.
+
 We can also use standalone data parser to parse date/numeric/color fields in data after it is parsed:
 
 am5.net.load("/data/mydata.csv").then(function(result) {

package/extended/concepts/serializing/chart-serializer.md

@@ -60,27 +60,19 @@ Comment
 
 Remove the empty objects from the resulting JSON.
 
-`includeProjection`
-
-`boolean`
-
-`false`
-
-Include `projection` setting for `MapChart`.
-
 `includeStates`
 
 `boolean`
 
-`false`
+`true`
 
 Include element and template states.
 
 `includeAdapters`
 
-boolean
+`boolean`
 
-`false`
+`true`
 
 Include adapters in the output.
 
@@ -100,43 +92,77 @@ Export functions as references or stringify them.
 
 Add a top-level `root` section with the `Root` object's settings and properties (`interfaceColors`, formatters, `utc`, `fps`, `tabindex`) to the output. `JsonParser` applies a `root` section before parsing the chart. *(5.20.2)*
 
-**What gets serialized (5.20.3+):** only **user-set** settings — theme and library defaults are left out, so the output is much smaller than in earlier versions and a value you never set will not appear. Chart-set values and data a chart builds for itself (a flow's nodes, a word cloud's words) are not written. Objects pointing at one another are written as references (e.g. `"@series.get('fill')"`) instead of copies, and big values (a map's `geoJSON`, a `Root`'s locale) are written as the name of the pack they came from and rebuilt on parse.
+`runningAnimations`
+
+`boolean`
+
+`true`
+
+Write an animation started in code that loops forever (`loops: Infinity`) into the element's `animations` setting, so the parsed chart plays it too. See "Animations" below. *(5.20.8)*
+
+**What gets serialized (5.20.3+):** only **user-set** settings — theme and library defaults are left out, so the output is much smaller than in earlier versions and a value you never set will not appear. Chart-set values and data a chart builds for itself (a flow's nodes, a word cloud's words) are not written. Objects pointing at one another are written as references (e.g. `"@series.get('fill')"`) instead of copies, and big values (a map's `geoJSON`, a `Root`'s locale) are written as the name of the pack they came from and rebuilt on parse. Since 5.20.7 a map series' data rows no longer carry the properties the map copies onto them from its geodata (`name`, and on some maps `CNTRY`, `TYPE`) — only values that differ from the feature's are written, and a row left with nothing but its id is dropped.
 
-The below instructs serializer to include both states and adapters in the output:
+Both states and adapters are included by default. The below instructs serializer to leave them out of the output:
 
 const serializer = am5plugins\_json.ChartSerializer.new(root, {
-  includeAdapters: true,
-  includeProjection: true
+  includeStates: false,
+  includeAdapters: false
 });
 
 var serializer = am5plugins\_json.ChartSerializer.new(root, {
-  includeAdapters: true,
-  includeProjection: true
+  includeStates: false,
+  includeAdapters: false
 });
 
+### Animations (5.20.8)
+
+An element's `animations` setting (see "[Animations: Declarative animations](https://www.amcharts.com/docs/v5/concepts/animations/)") is written as configured. A setting one of its entries animates is written with the value it was configured with, never one caught mid-animation.
+
+With `runningAnimations: true` (the default) *(5.20.8)*, an animation started in code with `animate()` that loops forever (`loops: Infinity`) and uses a named easing is written as an `animations` entry (`{ key, from, to, duration, loops: 0 }`, plus `easing`, `ease` and `yoyo` where they apply), and the setting it animates is left out of the output. A globe that keeps turning or a bullet that keeps pulsing thus plays on in the parsed chart.
+
+Never written:
+
+-   Animations that end: `appear()`, state transitions, zooming, any `animate()` with a finite `loops`.
+-   Animations whose easing is a function of your own, a wrapped `am5.ease.pow`, or an easing that cannot be named (e.g. `am5.ease.out(am5.ease.yoyo(...))`). `am5.ease.easingInfo()` tells whether an easing has a name.
+-   As of 5.20.8, a loop started in code on a **data item** (e.g. `dataItem.animate({ key: "positionOnLine", loops: Infinity })`). Declare it as an `animations` entry with `target: "dataItem"` on the bullet's sprite instead.
+
+To turn this off:
+
+```javascript
+var serializer = am5plugins_json.ChartSerializer.new(root, {
+  runningAnimations: false
+});
+```
+
 ### Including related elements
 
 #### Legend
 
 The serializer will detect `Legend` or `HeatLegend` and include it in the output if its a child of one of the chart's built-in containers, like `rightAxesContainer`, its series or the chart itself.
 
+Since 5.20.7 a legend placed inside an axis header (`axisHeader`) round-trips too. Before, parsing such a config failed with "Could not find ref", because the legend names a series defined further down the config (see "[Grouping referenced objects](https://www.amcharts.com/docs/v5/concepts/serializing/#Grouping_referenced_objects)").
+
 #### Custom elements
 
 Custom elements, like labels and the like, will not be included in the output unless the have a `"serialize"` in their `themeTags`:
 
 pieSeries.children.push(am5.Label.new(root, {
-  text: "Hello,
+  text: "Hello",
   x: am5.p50,
   y: am5.p50,
   themeTags: \["serialize"\]
-});
+}));
 
 pieSeries.children.push(am5.Label.new(root, {
-  text: "Hello,
+  text: "Hello",
   x: am5.p50,
   y: am5.p50,
   themeTags: \["serialize"\]
-});
+}));
+
+#### Theme tags (5.20.6)
+
+Since 5.20.6 the `themeTags` you give an element are written to the output too, so anything styled through them (e.g. a `Button` with `themeTags: ["switch"]`) keeps that styling when the config is parsed again. Only tags passed to the element's `.new()` call are written — tags added later via `set("themeTags", …)`, and tags the library adds itself, are left out. On parse, the tags are added to the ones an existing element already has rather than replacing them.
 
 ## Supported chart types
 
@@ -155,15 +181,14 @@ pieSeries.children.push(am5.Label.new(root, {
 
 -   Bullets (series or axis): No support for bullets that reference outside objects or context-based bullets (where bullet code depends on context to determine its appearance). Declare bullet factories as `function(root, series, dataItem)` — a factory that closes over an outer `root` dangles on re-bind.
 -   Bullets or adapters that rely on global variables. Parser runs in a different scope, thus global variables might not be available.
--   **Adapters do not round-trip.** With `includeAdapters: true` each adapter is written as `{ key, callback: "function (…) {…}" }` (a string) — `JsonParser` does not turn it back into a function. Before 5.20.4 the string was registered as a callback and crashed the chart (`i[s] is not a function` in `Entity.fold`); since 5.20.4 such adapters are skipped on parse. Prefer declarative equivalents (`colorByDataItem` on column series, per-item `fill` + `templateField`, `heatRules`).
+-   **Adapters do not round-trip.** With `includeAdapters: true` (the default) each adapter is written as `{ key, callback: "function (…) {…}" }` (a string) — `JsonParser` does not turn it back into a function. Before 5.20.4 the string was registered as a callback and crashed the chart (`i[s] is not a function` in `Entity.fold`); since 5.20.4 such adapters are skipped on parse. Prefer declarative equivalents (`colorByDataItem` on column series, per-item `fill` + `templateField`, `heatRules`).
 -   **Serialize the chart's top-level container child, not a bare series.** A series whose settings point back at itself (e.g. `selectedDataItem`, a `DataItem` whose `component` is the series) forms a cycle; serialized on its own it overflows `removeEmptyObjects` pruning or makes `JSON.stringify` throw "Converting circular structure". As a child of the serialized container it becomes a `#series-0` reference and the cycle disappears.
--   A bullet heat rule's throwaway sprite (created while the serializer introspects the bullet factory) has no `dataItem`; as of 5.20.5 the heat-rule loop then throws and, on a `LineSeries`, the stroke disappears. Have the factory call `sprite._setDataItem(dataItem)` or serialize before adding the rule.
+-   A bullet heat rule's throwaway sprite (created while the serializer introspects the bullet factory) has no `dataItem`; as of 5.20.8 the heat-rule loop then throws and, on a `LineSeries`, the stroke disappears. Have the factory call `sprite._setDataItem(dataItem)` or serialize before adding the rule.
 
 ### Unsupported features
 
--   Maps: Projections
+-   Maps: projections that are not registered by name. A projection set via `projectionName`, one of the bundled factories (`am5map.geoMercator()`, `am5map.geoOrthographic()`, etc.), or the factory returned by `am5map.registerProjection()` is written as `projectionName` and round-trips.
 -   Bullets: Full charts in bullets
--   Axes: Legend inside axis header
 -   Templates: `setup` function
 -   Custom draw functions
 -   Events

package/extended/concepts/serializing.md

@@ -22,6 +22,7 @@ Supported features:
 -   Properties
 -   Settings
 -   Adapters
+-   Declared animations — the `animations` setting *(5.20.8)*, see "[Animations](https://www.amcharts.com/docs/v5/concepts/animations/)". In a JSON config, colors and percents in an entry's `from`/`to` use the object form (`{ "type": "Color", "value": "#f00" }`, `{ "type": "Percent", "value": 50 }`).
 
 Unsupported features:
 
@@ -343,6 +344,8 @@ The items in the array will be processed one by one, so that references from the
 
 This way, a value can reference to any object from previous items.
 
+Since 5.20.7, a setting or property value that names a ref defined further down the config (later in the same `refs` object, or in a later group) no longer fails with "Could not find ref" — it is resolved after the rest of the config has been parsed. This is what makes e.g. a legend inside an axis header that lists a series defined later work. Groups are still the way to make sure an object is fully built before something uses it, and they are still required for [axis range](#Axis_ranges) definitions: a range's `axis` and `series` are looked up immediately, so the referenced axis and series need to come first, in an earlier group.
+
 {
   type: "XYChart",
   refs: \[{

package/extended/concepts/settings/template-fields.md

@@ -99,6 +99,30 @@ And the data:
 }\];
 
 
+## Backgrounds (5.20.7)
+
+A container's `background` (e.g. the background of a `Label`) has no data item of its own. Since 5.20.7, a background that has its own `templateField` reads the data item of the container it belongs to, so a background can be set per data item — for example, a different label background on each bullet:
+
+```javascript
+series.bullets.push(function (root, series, dataItem) {
+  return am5.Bullet.new(root, {
+    sprite: am5.Label.new(root, {
+      text: "{valueY}",
+      populateText: true,
+      background: am5.RoundedRectangle.new(root, {
+        templateField: "labelBg"
+      })
+    })
+  });
+});
+
+// Data
+// { date: ..., value: 1000, labelBg: { fill: am5.color(0xff0000) } }
+```
+
+Before 5.20.7 such a `templateField` on a background was never applied.
+
+
 ## Bullets
 
 There are some caveats involved when using template fields with bullets.

package/extended/examples/candlestick-ohlc/box-plot-chart.md

@@ -2,10 +2,11 @@
 title: "Box Plot Chart"
 source: "https://www.amcharts.com/demos/box-plot-chart/"
 category: "candlestick-ohlc"
-scraped: "2026-03-15"
+scraped: "2026-09-29"
 ---
 
-Box plot chart (also know as boxplot, box-and-whisker plot, box-and-whisker diagram) is a way of displaying statistical data based on five numbers: minimum, first quartile (25th percent), median, third quartile (75th percent) and maximum.
+Box plot chart (also known as boxplot, box-and-whisker plot, box-and-whisker diagram) is a way of displaying statistical data based on five numbers: minimum, first quartile (25th percentile), median, third quartile (75th percentile) and maximum.
+In this JavaScript box plot, each day's distribution is drawn with a CandlestickSeries: the box spans the first to the third quartile, and the whiskers reach the minimum and maximum. The median is a StepLineSeries with noRisers: true, which draws a horizontal line inside each box.
 XY chart
 Candlestick series
 Step line series
@@ -65,32 +66,35 @@ var series = chart.series.push(
   am5xy.CandlestickSeries.new(root, {
     fill: color,
     stroke: color,
-    name: "MDXI",
+    name: "Distribution",
     xAxis: xAxis,
     yAxis: yAxis,
-    valueYField: "close",
-    openValueYField: "open",
-    lowValueYField: "low",
-    highValueYField: "high",
+    // Box: first quartile (Q1) to third quartile (Q3); whiskers: minimum to maximum
+    valueYField: "q3",
+    openValueYField: "q1",
+    lowValueYField: "min",
+    highValueYField: "max",
     valueXField: "date",
     tooltip: am5.Tooltip.new(root, {
       pointerOrientation: "horizontal",
-      labelText: "open: {openValueY}
-low: {lowValueY}
-high: {highValueY}
-close: {valueY},
-mediana: {mediana}"
+      labelText: "Max: {highValueY}\nQ3: {valueY}\nMedian: {median}\nQ1: {openValueY}\nMin: {lowValueY}"
     })
   })
 );
 
-// mediana series
-var medianaSeries = chart.series.push(
+// Box plots use one colour: override the candlestick rise/drop colouring
+var boxColor = chart.get("colors").getIndex(0);
+am5.array.each(["riseFromOpen", "dropFromOpen", "riseFromPrevious", "dropFromPrevious"], function(state) {
+  series.columns.template.states.create(state, { fill: boxColor, stroke: boxColor });
+});
+
+// Median line inside each box
+var medianSeries = chart.series.push(
   am5xy.StepLineSeries.new(root, {
     stroke: root.interfaceColors.get("background"),
     xAxis: xAxis,
     yAxis: yAxis,
-    valueYField: "mediana",
+    valueYField: "median",
     valueXField: "date",
     noRisers: true
   })
@@ -103,95 +107,96 @@ var cursor = chart.set("cursor", am5xy.XYCursor.new(root, {
 }));
 cursor.lineY.set("visible", false);
 
+// Five-number summary for each day: minimum, first quartile, median, third quartile, maximum
 var data = [
   {
-    date: "2019-08-01",
-    open: 132.3,
-    high: 136.96,
-    low: 131.15,
-    close: 136.49
+    date: "2027-08-01",
+    min: 124.1,
+    q1: 129.6,
+    median: 132.2,
+    q3: 134.8,
+    max: 139.5
   },
   {
-    date: "2019-08-02",
-    open: 135.26,
-    high: 135.95,
-    low: 131.5,
-    close: 131.85
+    date: "2027-08-02",
+    min: 122.8,
+    q1: 128.4,
+    median: 131.0,
+    q3: 133.9,
+    max: 140.2
   },
   {
-    date: "2019-08-03",
-    open: 129.9,
-    high: 133.27,
-    low: 128.3,
-    close: 132.25
+    date: "2027-08-03",
+    min: 125.6,
+    q1: 130.1,
+    median: 133.4,
+    q3: 136.2,
+    max: 142.8
   },
   {
-    date: "2019-08-04",
-    open: 132.94,
-    high: 136.24,
-    low: 132.63,
-    close: 135.03
+    date: "2027-08-04",
+    min: 127.3,
+    q1: 131.8,
+    median: 134.0,
+    q3: 137.5,
+    max: 144.1
   },
   {
-    date: "2019-08-05",
-    open: 136.76,
-    high: 137.86,
-    low: 132.0,
-    close: 134.01
+    date: "2027-08-05",
+    min: 123.9,
+    q1: 129.2,
+    median: 131.7,
+    q3: 134.3,
+    max: 138.6
   },
   {
-    date: "2019-08-06",
-    open: 131.11,
-    high: 133.0,
-    low: 125.09,
-    close: 126.39
+    date: "2027-08-06",
+    min: 121.4,
+    q1: 127.5,
+    median: 130.3,
+    q3: 133.1,
+    max: 137.9
   },
   {
-    date: "2019-08-07",
-    open: 130.11,
-    high: 133.0,
-    low: 125.09,
-    close: 127.39
+    date: "2027-08-07",
+    min: 124.8,
+    q1: 130.6,
+    median: 133.9,
+    q3: 137.0,
+    max: 143.4
   },
   {
-    date: "2019-08-08",
-    open: 125.11,
-    high: 126.0,
-    low: 121.09,
-    close: 122.39
+    date: "2027-08-08",
+    min: 126.2,
+    q1: 131.4,
+    median: 134.6,
+    q3: 138.1,
+    max: 145.0
   },
   {
-    date: "2019-08-09",
-    open: 131.11,
-    high: 133.0,
-    low: 122.09,
-    close: 124.39
+    date: "2027-08-09",
+    min: 125.0,
+    q1: 130.2,
+    median: 132.8,
+    q3: 135.9,
+    max: 141.7
   }
 ];
 
-addMediana();
-
-function addMediana() {
-  for (var i = 0; i < data.length; i++) {
-    var dataItem = data[i];
-    dataItem.mediana =
-      Number(dataItem.low) + (Number(dataItem.high) - Number(dataItem.low)) / 2;
-  }
-}
-
 series.data.processor = am5.DataProcessor.new(root, {
   dateFields: ["date"],
   dateFormat: "yyyy-MM-dd"
 });
 
 series.data.setAll(data);
-medianaSeries.data.setAll(data);
+medianSeries.data.setAll(data);
 
 // Make stuff animate on load
 // https://www.amcharts.com/docs/v5/concepts/animations/
 series.appear(1000, 100);
-medianaSeries.appear(1000, 100);
-chart.appear(1000, 100);
+medianSeries.appear(1000, 100);
+chart.appear(1000, 100);
+
 ```
 
 ## HTML

package/extended/examples/candlestick-ohlc/candlestick-chart.md

@@ -2,7 +2,7 @@
 title: "Candlestick Chart"
 source: "https://www.amcharts.com/demos/candlestick-chart/"
 category: "candlestick-ohlc"
-scraped: "2026-03-15"
+scraped: "2026-09-29"
 ---
 
 Candlestick chart is one of the most common ways to display financial data such as stock trading prices over time. Creating candlestick charts with amCharts is really easy and you get a lot of advanced features such as grouping right out of the box (try zooming in and out).
@@ -121,10 +121,7 @@ var series = chart.series.push(
     legendRangeValueText: "{valueYClose}",
     tooltip: am5.Tooltip.new(root, {
       pointerOrientation: "horizontal",
-      labelText: "open: {openValueY}
-low: {lowValueY}
-high: {highValueY}
-close: {valueY}"
+      labelText: "open: {openValueY}\nlow: {lowValueY}\nhigh: {highValueY}\nclose: {valueY}"
     })
   })
 );