chartjs-chart-treemap 5.0.0-next.7 → 5.0.0-next.9

package/dist/chartjs-chart-treemap.cjs

@@ -1,5 +1,5 @@
 /*!
- * chartjs-chart-treemap v5.0.0-next.7
+ * chartjs-chart-treemap v5.0.0-next.9
  * https://chartjs-chart-treemap.pages.dev/
  * (c) 2026 Jukka Kurkela
  * Released under the MIT license
@@ -10,7 +10,7 @@ typeof define === 'function' && define.amd ? define(['exports', 'chart.js', 'cha
 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["chartjs-chart-treemap"] = {}, global.Chart, global.Chart.helpers));
 })(this, (function (exports, chart_js, helpers) { 'use strict';
 
-var version = "5.0.0-next.7";
+var version = "5.0.0-next.9";
 
 function scaleRect(sq, xScale, yScale, sp) {
     const sp2 = sp * 2;
@@ -60,6 +60,14 @@ function parseBorderRadius(value, maxW, maxH) {
 
 function getDims(itm, w2, s2, key) {
     const a = itm._normalized;
+    if (!a) {
+        return {
+            d1: 0,
+            d2: 0,
+            h: 0,
+            w: 0
+        };
+    }
     const ar = w2 * a / s2;
     const d1 = Math.sqrt(a * ar);
     const d2 = a / d1;
@@ -427,6 +435,7 @@ function requireVersion(pkg, min, ver, strict = true) {
     return true;
 }
 
+const WEIGHT_KEY = '_weight';
 function compareAspectRatio(oldStat, newStat, args) {
     if (oldStat.sum === 0) {
         return true;
@@ -460,16 +469,17 @@ function compareAspectRatio(oldStat, newStat, args) {
         return node;
     });
 }
- function sortNodes(nodes) {
-    sort(nodes, 'v');
+ function sortNodes(nodes, weighted = false) {
+    sort(nodes, weighted ? WEIGHT_KEY : 'v');
 }
- function packInto(nodes, rectangle) {
+ function packInto(nodes, rectangle, weighted = false) {
     const n = nodes.length;
     if (!n) {
         return;
     }
+    const key = weighted ? WEIGHT_KEY : 'v';
     const rect = new Rect(rectangle);
-    const row = new StatArray('v', rect.area / sum(nodes, 'v'));
+    const row = new StatArray(key, rect.area / sum(nodes, key));
     let length = rect.side;
     let o;
     for(let i = 0; i < n; ++i){
@@ -486,7 +496,272 @@ function compareAspectRatio(oldStat, newStat, args) {
     }
 }
 
+const WIDTH_CACHE_LIMIT = 4096;
 const widthCache = new Map();
+const fontFor = (fonts, index)=>fonts[Math.min(index, fonts.length - 1)];
+function measureLabelSize(ctx, lines, fonts) {
+    const fontsKey = fonts.reduce((prev, item)=>{
+        prev += item.string;
+        return prev;
+    }, '');
+    const mapKey = lines.join() + fontsKey + (ctx._measureText ? '-spriting' : '');
+    let size = widthCache.get(mapKey);
+    if (!size) {
+        ctx.save();
+        const count = lines.length;
+        let width = 0;
+        let height = 0;
+        for(let i = 0; i < count; i++){
+            const font = fonts[Math.min(i, fonts.length - 1)];
+            ctx.font = font.string;
+            const text = lines[i];
+            width = Math.max(width, ctx.measureText(text).width);
+            height += font.lineHeight;
+        }
+        ctx.restore();
+        size = {
+            height,
+            width
+        };
+        if (widthCache.size >= WIDTH_CACHE_LIMIT) {
+            widthCache.clear();
+        }
+        widthCache.set(mapKey, size);
+    }
+    return size;
+}
+function measureLines(ctx, lines, styles, fonts) {
+    let width = 0;
+    let height = 0;
+    lines.forEach((line, i)=>{
+        const font = fontFor(fonts, styles[i]);
+        width = Math.max(width, measureLabelSize(ctx, [
+            line
+        ], [
+            font
+        ]).width);
+        height += font.lineHeight;
+    });
+    return {
+        height,
+        width
+    };
+}
+function toFonts(fonts, fitRatio) {
+    return fonts.map((f)=>{
+        const { lineHeight: _lineHeight, ...font } = f;
+        return helpers.toFont({
+            ...font,
+            size: Math.floor(f.size * fitRatio)
+        });
+    });
+}
+
+function clipToPadding(ctx, rect, padding, clipY) {
+    const x = Math.max(0, padding);
+    const y = Math.max(0, clipY);
+    ctx.beginPath();
+    ctx.rect(rect.x + x, rect.y + y, Math.max(0, rect.w - 2 * x), Math.max(0, rect.h - 2 * y));
+    ctx.clip();
+}
+function drawTextBlock(ctx, rect, block) {
+    const { align, colors, fonts, lines, padding, styles, textAlign, top, width } = block;
+    const lineAlign = textAlign || align;
+    const x = calculateLineX(rect, align, lineAlign, padding, width);
+    ctx.textAlign = lineAlign;
+    ctx.textBaseline = 'middle';
+    let offset = 0;
+    lines.forEach((line, i)=>{
+        const style = styles[i];
+        const font = fontFor(fonts, style);
+        ctx.font = font.string;
+        ctx.fillStyle = colors[Math.min(style, colors.length - 1)];
+        ctx.fillText(line, x, top + offset + font.lineHeight / 2);
+        offset += font.lineHeight;
+    });
+}
+function calculateBlockTop(rect, options, labelSize) {
+    const { position, padding } = options;
+    if (position === 'top') {
+        return rect.y + padding;
+    }
+    if (position === 'bottom') {
+        return rect.y + rect.h - padding - labelSize.height;
+    }
+    return rect.y + (rect.h - labelSize.height) / 2 + padding;
+}
+ function calculateBlockLeft(rect, align, padding, width) {
+    if (align === 'left') {
+        return rect.x + padding;
+    }
+    if (align === 'right') {
+        return rect.x + rect.w - padding - width;
+    }
+    return rect.x + (rect.w - width) / 2;
+}
+function calculateLineX(rect, align, lineAlign, padding, width) {
+    if (align === lineAlign) {
+        if (align === 'left') {
+            return rect.x + padding;
+        }
+        if (align === 'right') {
+            return rect.x + rect.w - padding;
+        }
+        return rect.x + rect.w / 2;
+    }
+    const left = calculateBlockLeft(rect, align, padding, width);
+    if (lineAlign === 'left') {
+        return left;
+    }
+    if (lineAlign === 'right') {
+        return left + width;
+    }
+    return left + width / 2;
+}
+
+function sliceTextToFitWidth(ctx, text, width, fonts) {
+    const ellipsis = '...';
+    const ellipsisWidth = measureLabelSize(ctx, [
+        ellipsis
+    ], fonts).width;
+    if (ellipsisWidth >= width) {
+        return '';
+    }
+    let lowerBoundLen = 1;
+    let upperBoundLen = text.length;
+    let currentWidth;
+    while(lowerBoundLen <= upperBoundLen){
+        const currentLen = Math.floor((lowerBoundLen + upperBoundLen) / 2);
+        const currentText = text.slice(0, currentLen);
+        currentWidth = measureLabelSize(ctx, [
+            currentText
+        ], fonts).width;
+        if (currentWidth + ellipsisWidth > width) {
+            upperBoundLen = currentLen - 1;
+        } else {
+            lowerBoundLen = currentLen + 1;
+        }
+    }
+    const slicedText = text.slice(0, Math.max(0, lowerBoundLen - 1));
+    return slicedText ? slicedText + ellipsis : '';
+}
+function applyEllipsis(ctx, lines, styles, fonts, maxWidth, maxHeight) {
+    const keptLines = [];
+    const keptStyles = [];
+    let used = 0;
+    for(let i = 0; i < lines.length; i++){
+        const font = fontFor(fonts, styles[i]);
+        if (keptLines.length && used + font.lineHeight > maxHeight) {
+            break;
+        }
+        used += font.lineHeight;
+        keptLines.push(lines[i]);
+        keptStyles.push(styles[i]);
+    }
+    const dropped = keptLines.length < lines.length;
+    const last = keptLines.length - 1;
+    for(let i = 0; i < keptLines.length; i++){
+        const font = fontFor(fonts, keptStyles[i]);
+        const tooWide = measureLabelSize(ctx, [
+            keptLines[i]
+        ], [
+            font
+        ]).width > maxWidth;
+        if (tooWide || dropped && i === last) {
+            keptLines[i] = sliceTextToFitWidth(ctx, keptLines[i], maxWidth, [
+                font
+            ]);
+        }
+    }
+    return {
+        lines: keptLines,
+        styles: keptStyles
+    };
+}
+function labelToDraw(rect, options, labelSize) {
+    const { overflow, padding } = options;
+    const { width, height } = labelSize;
+    if (overflow === 'hidden') {
+        return !(width + padding * 2 > rect.w || height + padding * 2 > rect.h);
+    } else if (overflow === 'fit') {
+        const ratio = Math.min(rect.w / (width + padding * 2), rect.h / (height + padding * 2));
+        if (ratio < 1) {
+            return ratio;
+        }
+    }
+    return true;
+}
+
+function wrapToWidth(ctx, text, font, width) {
+    if (width <= 0) {
+        return [
+            text
+        ];
+    }
+    const fits = (value)=>measureLabelSize(ctx, [
+            value
+        ], [
+            font
+        ]).width <= width;
+    const lines = [];
+    let line = '';
+    const pushWord = (word)=>{
+        if (fits(word)) {
+            line = word;
+            return;
+        }
+        let chunk = '';
+        for (const char of word){
+            if (chunk && !fits(chunk + char)) {
+                lines.push(chunk);
+                chunk = '';
+            }
+            chunk += char;
+        }
+        line = chunk;
+    };
+    for (const word of text.split(' ')){
+        const candidate = line ? `${line} ${word}` : word;
+        if (fits(candidate)) {
+            line = candidate;
+            continue;
+        }
+        if (line) {
+            lines.push(line);
+            line = '';
+        }
+        pushWord(word);
+    }
+    if (line) {
+        lines.push(line);
+    }
+    return lines.length ? lines : [
+        ''
+    ];
+}
+function toLines(ctx, content, fonts, width, wrap) {
+    const paragraphs = (helpers.isArray(content) ? content : [
+        content
+    ]).map((entry)=>`${entry}`);
+    const lines = [];
+    const styles = [];
+    paragraphs.forEach((paragraph, index)=>{
+        const font = fontFor(fonts, index);
+        for (const piece of paragraph.split('\n')){
+            for (const line of wrap ? wrapToWidth(ctx, piece, font, width) : [
+                piece
+            ]){
+                lines.push(line);
+                styles.push(index);
+            }
+        }
+    });
+    return {
+        lines,
+        styles
+    };
+}
+
 function shouldDrawCaption(displayMode, rect, options) {
     if (!options || options.display === false) {
         return false;
@@ -526,28 +801,6 @@ function drawText(ctx, rect, options, item, element, layout) {
     clipToPadding(ctx, rect, block.padding, block.clipY);
     drawTextBlock(ctx, rect, block);
     ctx.restore();
-}
- function clipToPadding(ctx, rect, padding, clipY) {
-    const x = Math.max(0, padding);
-    const y = Math.max(0, clipY);
-    ctx.beginPath();
-    ctx.rect(rect.x + x, rect.y + y, Math.max(0, rect.w - 2 * x), Math.max(0, rect.h - 2 * y));
-    ctx.clip();
-}
-function drawTextBlock(ctx, rect, block) {
-    const { align, colors, fonts, lines, padding, textAlign, top, width } = block;
-    const lineAlign = textAlign || align;
-    const x = calculateLineX(rect, align, lineAlign, padding, width);
-    ctx.textAlign = lineAlign;
-    ctx.textBaseline = 'middle';
-    let offset = 0;
-    lines.forEach((line, i)=>{
-        const font = fonts[Math.min(i, fonts.length - 1)];
-        ctx.font = font.string;
-        ctx.fillStyle = colors[Math.min(i, colors.length - 1)];
-        ctx.fillText(line, x, top + offset + font.lineHeight / 2);
-        offset += font.lineHeight;
-    });
 }
 function callbackContext(element, item) {
     const context = element.$context || {
@@ -573,10 +826,17 @@ function resolveCaptionText(captions, element, item) {
     const padding = captions.padding;
     if (measureLabelSize(ctx, [
         text
-    ], fonts).width + 2 * padding > rect.w) {
-        return sliceTextToFitWidth(ctx, text, rect.w - 2 * padding, fonts);
+    ], fonts).width + 2 * padding <= rect.w) {
+        return text;
     }
-    return text;
+    const overflow = captions.overflow || 'ellipsis';
+    if (overflow === 'hidden') {
+        return undefined;
+    }
+    if (overflow === 'cut') {
+        return text;
+    }
+    return sliceTextToFitWidth(ctx, text, rect.w - 2 * padding, fonts);
 }
 function captionBlock(ctx, rect, options, item, element, layout) {
     const { displayMode, rtl, spacing } = layout;
@@ -608,6 +868,9 @@ function captionBlock(ctx, rect, options, item, element, layout) {
             text
         ],
         padding,
+        styles: [
+            0
+        ],
         textAlign: captions.textAlign,
         top,
         width: measureLabelSize(ctx, [
@@ -621,23 +884,36 @@ function labelBlock(ctx, rect, options, item, element) {
     if (!content) {
         return;
     }
-    const lines = helpers.isArray(content) ? content : [
-        content
-    ];
+    const { align, color, hoverColor, overflow, padding, wrap } = labels;
+    const maxWidth = rect.w - padding * 2;
+    const maxHeight = rect.h - padding * 2;
     let fonts = getFontFromOptions(rect, labels);
-    let labelSize = measureLabelSize(ctx, lines, fonts);
+    let { lines, styles } = toLines(ctx, content, fonts, maxWidth, !!wrap);
+    let labelSize = measureLines(ctx, lines, styles, fonts);
     const lblToDraw = labelToDraw(rect, labels, labelSize);
     if (!lblToDraw) {
         return;
     }
     if (helpers.isNumber(lblToDraw)) {
-        labelSize = {
-            height: labelSize.height * lblToDraw,
-            width: labelSize.width * lblToDraw
-        };
         fonts = toFonts(fonts, lblToDraw);
+        if (wrap) {
+            const rewrapped = toLines(ctx, content, fonts, maxWidth, true);
+            lines = rewrapped.lines;
+            styles = rewrapped.styles;
+            labelSize = measureLines(ctx, lines, styles, fonts);
+        } else {
+            labelSize = {
+                height: labelSize.height * lblToDraw,
+                width: labelSize.width * lblToDraw
+            };
+        }
+    }
+    if (overflow === 'ellipsis') {
+        const trimmed = applyEllipsis(ctx, lines, styles, fonts, maxWidth, maxHeight);
+        lines = trimmed.lines;
+        styles = trimmed.styles;
+        labelSize = measureLines(ctx, lines, styles, fonts);
     }
-    const { color, hoverColor, align, padding } = labels;
     const optColor = (rect.active ? hoverColor : color) || color;
     return {
         align,
@@ -648,87 +924,12 @@ function labelBlock(ctx, rect, options, item, element) {
         fonts,
         lines,
         padding,
+        styles,
         textAlign: labels.textAlign,
         top: calculateBlockTop(rect, labels, labelSize),
         width: labelSize.width
     };
 }
-function sliceTextToFitWidth(ctx, text, width, fonts) {
-    const ellipsis = '...';
-    const ellipsisWidth = measureLabelSize(ctx, [
-        ellipsis
-    ], fonts).width;
-    if (ellipsisWidth >= width) {
-        return '';
-    }
-    let lowerBoundLen = 1;
-    let upperBoundLen = text.length;
-    let currentWidth;
-    while(lowerBoundLen <= upperBoundLen){
-        const currentLen = Math.floor((lowerBoundLen + upperBoundLen) / 2);
-        const currentText = text.slice(0, currentLen);
-        currentWidth = measureLabelSize(ctx, [
-            currentText
-        ], fonts).width;
-        if (currentWidth + ellipsisWidth > width) {
-            upperBoundLen = currentLen - 1;
-        } else {
-            lowerBoundLen = currentLen + 1;
-        }
-    }
-    const slicedText = text.slice(0, Math.max(0, lowerBoundLen - 1));
-    return slicedText ? slicedText + ellipsis : '';
-}
-function measureLabelSize(ctx, lines, fonts) {
-    const fontsKey = fonts.reduce((prev, item)=>{
-        prev += item.string;
-        return prev;
-    }, '');
-    const mapKey = lines.join() + fontsKey + (ctx._measureText ? '-spriting' : '');
-    let size = widthCache.get(mapKey);
-    if (!size) {
-        ctx.save();
-        const count = lines.length;
-        let width = 0;
-        let height = 0;
-        for(let i = 0; i < count; i++){
-            const font = fonts[Math.min(i, fonts.length - 1)];
-            ctx.font = font.string;
-            const text = lines[i];
-            width = Math.max(width, ctx.measureText(text).width);
-            height += font.lineHeight;
-        }
-        ctx.restore();
-        size = {
-            height,
-            width
-        };
-        widthCache.set(mapKey, size);
-    }
-    return size;
-}
-function toFonts(fonts, fitRatio) {
-    return fonts.map((f)=>{
-        const { lineHeight: _lineHeight, ...font } = f;
-        return helpers.toFont({
-            ...font,
-            size: Math.floor(f.size * fitRatio)
-        });
-    });
-}
-function labelToDraw(rect, options, labelSize) {
-    const { overflow, padding } = options;
-    const { width, height } = labelSize;
-    if (overflow === 'hidden') {
-        return !(width + padding * 2 > rect.w || height + padding * 2 > rect.h);
-    } else if (overflow === 'fit') {
-        const ratio = Math.min(rect.w / (width + padding * 2), rect.h / (height + padding * 2));
-        if (ratio < 1) {
-            return ratio;
-        }
-    }
-    return true;
-}
 function getFontFromOptions(rect, labels) {
     const { font, hoverFont } = labels;
     const optFont = (rect.active ? hoverFont : font) || font;
@@ -736,58 +937,17 @@ function getFontFromOptions(rect, labels) {
         helpers.toFont(optFont)
     ];
 }
-function calculateBlockTop(rect, options, labelSize) {
-    const { position, padding } = options;
-    if (position === 'top') {
-        return rect.y + padding;
-    }
-    if (position === 'bottom') {
-        return rect.y + rect.h - padding - labelSize.height;
-    }
-    return rect.y + (rect.h - labelSize.height) / 2 + padding;
-}
- function calculateBlockLeft(rect, align, padding, width) {
-    if (align === 'left') {
-        return rect.x + padding;
-    }
-    if (align === 'right') {
-        return rect.x + rect.w - padding - width;
-    }
-    return rect.x + (rect.w - width) / 2;
-}
- function calculateLineX(rect, align, lineAlign, padding, width) {
-    if (align === lineAlign) {
-        if (align === 'left') {
-            return rect.x + padding;
-        }
-        if (align === 'right') {
-            return rect.x + rect.w - padding;
-        }
-        return rect.x + rect.w / 2;
-    }
-    const left = calculateBlockLeft(rect, align, padding, width);
-    if (lineAlign === 'left') {
-        return left;
-    }
-    if (lineAlign === 'right') {
-        return left + width;
-    }
-    return left + width / 2;
-}
 
-function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
+function buildHierarchy(values, gidx, keys, layout, weighted, parentGroupValue) {
     const { groups, leafKey, unsorted } = layout;
     const glen = groups.length;
     const g = getGroupKey(groups[gidx]);
     const gdata = group(values, g, keys, leafKey, undefined, parentGroupValue, groups.filter((_item, index)=>index <= gidx), groups, gidx);
     const nodes = toNodes(gdata, keys, g, gidx);
-    if (!unsorted) {
-        sortNodes(nodes);
-    }
     for (const node of nodes){
         const record = node._data;
         const nextGroupIndex = record.groupIndex + 1;
-        const children = gidx < glen - 1 && nextGroupIndex < glen ? buildHierarchy(record.children, nextGroupIndex, keys, layout, node.g) : [];
+        const children = gidx < glen - 1 && nextGroupIndex < glen ? buildHierarchy(record.children, nextGroupIndex, keys, layout, weighted, node.g) : [];
         Object.defineProperty(node, '_children', {
             configurable: true,
             value: children,
@@ -795,8 +955,91 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
         });
         node.isLeaf = !children.length;
     }
-    return nodes;
+    if (weighted) {
+        applyValueScale(nodes, scaleFor(layout));
+    }
+    const withOthers = layout.others ? applyOthers(nodes, layout.others, weighted) : nodes;
+    if (!unsorted) {
+        sortNodes(withOthers, weighted);
+    }
+    return withOthers;
 }
+ function applyValueScale(nodes, scale) {
+    for (const node of nodes){
+        const children = node._children;
+        let weight;
+        if (children?.length) {
+            applyValueScale(children, scale);
+            weight = children.reduce((total, child)=>total + child[WEIGHT_KEY], 0);
+        } else {
+            const scaled = scale(node.v, node._data);
+            weight = Number.isFinite(scaled) && scaled > 0 ? scaled : 0;
+        }
+        Object.defineProperty(node, WEIGHT_KEY, {
+            configurable: true,
+            value: weight,
+            writable: true
+        });
+    }
+}
+ function applyOthers(nodes, others, weighted) {
+    const { label = 'Other', minCount = 2, threshold } = others;
+    if (!(threshold > 0) || nodes.some((node)=>node._children?.length)) {
+        return nodes;
+    }
+    const weightOf = (node)=>weighted ? node[WEIGHT_KEY] : node.v;
+    const total = nodes.reduce((sum, node)=>sum + weightOf(node), 0);
+    if (!(total > 0)) {
+        return nodes;
+    }
+    const small = nodes.filter((node)=>weightOf(node) / total < threshold);
+    if (small.length < Math.max(2, minCount)) {
+        return nodes;
+    }
+    const kept = nodes.filter((node)=>!small.includes(node));
+    const bucket = {
+        _data: {
+            label,
+            others: small.map((node)=>node._data)
+        },
+        h: 0,
+        isLeaf: true,
+        isOthers: true,
+        s: 0,
+        v: small.reduce((sum, node)=>sum + node.v, 0),
+        vs: sumValues(small),
+        w: 0,
+        x: 0,
+        y: 0
+    };
+    const grouped = nodes.find((node)=>node.g !== undefined);
+    if (grouped) {
+        bucket.g = label;
+        bucket.l = grouped.l;
+    }
+    if (weighted) {
+        Object.defineProperty(bucket, WEIGHT_KEY, {
+            configurable: true,
+            value: small.reduce((sum, node)=>sum + weightOf(node), 0),
+            writable: true
+        });
+    }
+    kept.push(bucket);
+    return kept;
+}
+ function sumValues(nodes) {
+    const totals = {};
+    for (const node of nodes){
+        for (const [key, value] of Object.entries(node.vs || {})){
+            totals[key] = (totals[key] || 0) + value;
+        }
+    }
+    return Object.keys(totals).length ? totals : undefined;
+}
+const VALUE_SCALES = {
+    log: (value)=>Math.log1p(Math.max(value, 0)),
+    sqrt: (value)=>Math.sqrt(Math.max(value, 0))
+};
  function flattenNodes(nodes) {
     const flat = nodes.slice();
     for (const node of nodes){
@@ -806,22 +1049,33 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
     }
     return flat;
 }
- function layoutLevel(nodes, rect, layout, parentSum) {
+ function layoutLevel(nodes, rect, layout, weighted, parentSum) {
     if (parentSum !== undefined) {
         for (const node of nodes){
             node.gs = parentSum;
         }
     }
-    packInto(nodes, rect);
+    packInto(nodes, rect, weighted);
     for (const node of nodes){
         if (node._children?.length) {
-            layoutLevel(node._children, getSubRect(node, rect, layout), layout, node.s);
+            layoutLevel(node._children, getSubRect(node, rect, layout), layout, weighted, node.s);
         }
     }
 }
  function layoutNodes(nodes, rect, layout) {
-    layoutLevel(nodes, rect, layout);
+    layoutLevel(nodes, rect, layout, isWeighted(layout));
     applyHeaderBoxes(flattenNodes(nodes), layout);
+}
+ function isWeighted(layout) {
+    const scale = layout.valueScale;
+    return scale !== 'linear' && scale !== undefined;
+}
+function scaleFor(layout) {
+    const scale = layout.valueScale;
+    if (typeof scale === 'function') {
+        return scale;
+    }
+    return VALUE_SCALES[scale] || ((value)=>value);
 }
  function getSubRect(sq, rect, layout) {
     const { borderWidth, captions, displayMode } = layout;
@@ -849,12 +1103,21 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
  function buildNodes(tree, keys, layout) {
     const { groups, leafKey, unsorted } = layout;
     const input = helpers.isObject(tree) ? normalizeTreeToArray(keys, leafKey, tree) : tree;
+    const weighted = isWeighted(layout);
+    let nodes;
     if (groups.length) {
-        return buildHierarchy(input, 0, keys, layout);
-    }
-    const nodes = toNodes(input || [], keys);
-    if (!unsorted) {
-        sortNodes(nodes);
+        nodes = buildHierarchy(input, 0, keys, layout, weighted);
+    } else {
+        nodes = toNodes(input || [], keys);
+        if (weighted) {
+            applyValueScale(nodes, scaleFor(layout));
+        }
+        if (layout.others) {
+            nodes = applyOthers(nodes, layout.others, weighted);
+        }
+        if (!unsorted) {
+            sortNodes(nodes, weighted);
+        }
     }
     return nodes;
 }
@@ -878,6 +1141,9 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
     }
 }
 
+function clampFraction(value, fallback) {
+    return value === undefined ? fallback : Math.min(Math.max(value, 0), 1);
+}
 function registerTooltipPositioner() {
     const tooltipPlugin = chart_js.registry.plugins.get('tooltip');
     if (!tooltipPlugin || tooltipPlugin.positioners.treemap) {
@@ -912,12 +1178,9 @@ class TreemapController extends chart_js.DatasetController {
         const w = xScale.right - xScale.left;
         const h = yScale.bottom - yScale.top;
         const rect = {
-            h,
+            ...this._regionBounds(w, h),
             rtl: !!this.options.rtl,
-            unsorted: !!this.options.unsorted,
-            w,
-            x: 0,
-            y: 0
+            unsorted: !!this.options.unsorted
         };
         if (rectNotEqual(this._rect, rect)) {
             this._rect = rect;
@@ -930,6 +1193,31 @@ class TreemapController extends chart_js.DatasetController {
             yScale.configure();
         }
     }
+ _regionBounds(w, h) {
+        const region = this.options.region;
+        if (!region) {
+            return {
+                h,
+                w,
+                x: 0,
+                y: 0
+            };
+        }
+        const left = clampFraction(region.left, 0);
+        const top = clampFraction(region.top, 0);
+        const width = clampFraction(region.width, 1);
+        const height = clampFraction(region.height, 1);
+        if (!this._regionWarned && (left + width > 1 || top + height > 1)) {
+            this._regionWarned = true;
+            console.warn('chartjs-chart-treemap: a dataset region reaches outside the chart area and is clipped to it.');
+        }
+        return {
+            h: h * Math.min(height, 1 - top),
+            w: w * Math.min(width, 1 - left),
+            x: w * left,
+            y: h * top
+        };
+    }
  _layoutOptions() {
         const dataset = this.getDataset();
         const options = this.options;
@@ -939,8 +1227,10 @@ class TreemapController extends chart_js.DatasetController {
             displayMode: options.displayMode,
             groups: options.groups || [],
             leafKey: options.leafKey,
+            others: options.others || false,
             spacing: helpers.valueOrDefault(dataset.spacing, 0),
-            unsorted: !!options.unsorted
+            unsorted: !!options.unsorted,
+            valueScale: options.valueScale || 'linear'
         };
     }
  buildOrUpdateElements(_resetNewElements) {
@@ -995,8 +1285,10 @@ class TreemapController extends chart_js.DatasetController {
         }
         const dataset = this.getDataset();
         const label = node.g ?? node._data?.label ?? dataset.label;
+        const text = label === undefined ? '' : `${label}`;
+        const others = node.isOthers ? node._data?.others?.length : undefined;
         return {
-            label: label === undefined ? '' : `${label}`,
+            label: others ? `${text} (${others} items)` : text,
             value: `${node.v}`
         };
     }
@@ -1058,6 +1350,7 @@ class TreemapController extends chart_js.DatasetController {
         super(chart, datasetIndex);
         this._rect = undefined;
         this._rectChanged = true;
+        this._regionWarned = false;
         this._nodes = [];
         this._layoutDirty = true;
         this._fingerprint = undefined;
@@ -1082,10 +1375,13 @@ TreemapController.defaults = {
     groups: [],
     key: '',
     leafKey: '_leaf',
+    others: false,
+    region: undefined,
     rtl: layoutDefaults.rtl,
     spacing: layoutDefaults.spacing,
     sumKeys: [],
-    unsorted: false
+    unsorted: false,
+    valueScale: 'linear'
 };
 TreemapController.descriptors = {
     _indexable: false,
@@ -1283,6 +1579,7 @@ TreemapElement.defaults = {
             const label = ctx.raw._data?.label;
             return ctx.raw.g || (typeof label === 'string' ? label : '');
         },
+        overflow: 'ellipsis',
         padding: 3,
         textAlign: undefined
     },
@@ -1307,7 +1604,8 @@ TreemapElement.defaults = {
         overflow: 'cut',
         padding: 3,
         position: 'middle',
-        textAlign: undefined
+        textAlign: undefined,
+        wrap: false
     }
 };
 TreemapElement.descriptors = {