@genome-spy/core 0.78.0 → 0.79.0

package/dist/src/view/layout/flexLayout.js

@@ -12,6 +12,8 @@ import { isStepSize } from "../view.js";
  * @typedef {object} SizeDef Size definition inspired by CSS flexbox
  * @prop {number} [px] Size in pixels
  * @prop {number} [grow] Share of remaining space
+ * @prop {number} [minPx] Minimum size in pixels
+ * @prop {number} [maxPx] Maximum size in pixels
  *
  * @typedef {object} LocSize One-dimensional location and size
  * @prop {number} location
@@ -37,16 +39,17 @@ export function mapToPixelCoords(
     spacing = spacing || 0;
     offset = offset || 0;
 
-    let totalPx = 0;
-    let totalGrow = 0;
+    const itemSizes = resolveItemSizes(items, containerSize, spacing);
 
-    for (const size of items) {
-        totalPx += z(size.px) + (isZeroSizeDef(size) ? 0 : spacing);
-        totalGrow += z(size.grow);
+    let totalSize = 0;
+    let nonZeroCount = 0;
+    for (let i = 0; i < items.length; i++) {
+        totalSize += itemSizes[i];
+        if (!isZeroSizeDef(items[i])) {
+            nonZeroCount++;
+        }
     }
-    totalPx -= spacing;
-
-    const remainingSpace = Math.max(0, containerSize - totalPx);
+    const totalPx = totalSize + Math.max(0, nonZeroCount - 1) * spacing;
 
     /** @type {function(number):number} x */
     const round =
@@ -57,9 +60,8 @@ export function mapToPixelCoords(
     /**
      * Buffer zero-sized items so that their locations can be spread evenly.
      * They can then be interpolated nicely.
-     * @type {SizeDef[]}
      */
-    const zeroBuffer = [];
+    let zeroCount = 0;
 
     /** @type {LocSize[]} */
     const results = [];
@@ -70,7 +72,7 @@ export function mapToPixelCoords(
      * @param {boolean} inMiddle
      */
     const flushZeroBuffer = (inMiddle) => {
-        const n = zeroBuffer.length;
+        const n = zeroCount;
         if (!n) {
             return;
         }
@@ -86,7 +88,7 @@ export function mapToPixelCoords(
         }
         x += s;
 
-        zeroBuffer.length = 0;
+        zeroCount = 0;
     };
 
     let x = reverse ? Math.max(containerSize, totalPx) : 0 + offset;
@@ -100,13 +102,11 @@ export function mapToPixelCoords(
         const size = items[i];
 
         if (isZeroSizeDef(size)) {
-            zeroBuffer.push(size);
+            zeroCount++;
         } else {
             flushZeroBuffer(results.length > 0);
 
-            const advance =
-                z(size.px) +
-                (totalGrow ? (z(size.grow) / totalGrow) * remainingSpace : 0);
+            const advance = itemSizes[i];
 
             if (reverse) {
                 x -= advance;
@@ -139,7 +139,8 @@ export function mapToPixelCoords(
 export function getMinimumSize(items, { spacing } = { spacing: 0 }) {
     let minimumSize = 0;
     for (const size of items) {
-        minimumSize += z(size.px) + (isZeroSizeDef(size) ? 0 : spacing);
+        minimumSize +=
+            getSizeDefMinPx(size) + (isZeroSizeDef(size) ? 0 : spacing);
     }
     return Math.max(0, minimumSize - spacing);
 }
@@ -151,12 +152,29 @@ export function getMinimumSize(items, { spacing } = { spacing: 0 }) {
 export function getLargestSize(items) {
     let px = 0;
     let grow = 0;
+    let minPx = 0;
+    let maxPx = undefined;
+    let hasMaxPx = true;
     for (const s of items) {
         px = Math.max(px, s.px ?? 0);
         grow = Math.max(grow, s.grow ?? 0);
+        minPx = Math.max(minPx, getSizeDefMinPx(s));
+
+        const sizeMaxPx = getSizeDefMaxPx(s);
+        if (sizeMaxPx === undefined) {
+            hasMaxPx = false;
+        } else {
+            maxPx =
+                maxPx === undefined ? sizeMaxPx : Math.max(maxPx, sizeMaxPx);
+        }
     }
 
-    return { px, grow };
+    return createSizeDef({
+        px,
+        grow,
+        minPx,
+        maxPx: hasMaxPx ? maxPx : undefined,
+    });
 }
 
 /**
@@ -172,12 +190,24 @@ export function isStretching(items) {
  * @param {SizeDef[]} sizeDefs
  */
 export function sumSizeDefs(sizeDefs) {
-    const sum = { px: 0, grow: 0 };
+    const sum = { px: 0, grow: 0, minPx: 0, maxPx: 0 };
+    let hasMaxPx = true;
     for (const size of sizeDefs) {
         sum.px += z(size.px);
         sum.grow += z(size.grow);
+        sum.minPx += getSizeDefMinPx(size);
+
+        const sizeMaxPx = getSizeDefMaxPx(size);
+        if (sizeMaxPx === undefined) {
+            hasMaxPx = false;
+        } else {
+            sum.maxPx += sizeMaxPx;
+        }
     }
-    return sum;
+    if (!hasMaxPx) {
+        delete sum.maxPx;
+    }
+    return createSizeDef(sum);
 }
 
 export class FlexDimensions {
@@ -218,14 +248,8 @@ export class FlexDimensions {
      */
     #addPx(width, height) {
         return new FlexDimensions(
-            {
-                px: (this.width.px ?? 0) + width,
-                grow: this.width.grow,
-            },
-            {
-                px: (this.height.px ?? 0) + height,
-                grow: this.height.grow,
-            }
+            addPxToSizeDef(this.width, width),
+            addPxToSizeDef(this.height, height)
         );
     }
 
@@ -260,7 +284,7 @@ export const ZERO_FLEXDIMENSIONS = new FlexDimensions(
  * @param {SizeDef} sizeDef
  */
 export function isZeroSizeDef(sizeDef) {
-    return !sizeDef.px && !sizeDef.grow;
+    return !sizeDef.px && !sizeDef.grow && !sizeDef.minPx;
 }
 
 /**
@@ -278,7 +302,13 @@ function z(value) {
  * @returns {spec is SizeDef}
  */
 export function isSizeDef(spec) {
-    return spec && (isNumber(spec.px) || isNumber(spec.grow));
+    return (
+        spec &&
+        (isNumber(spec.px) ||
+            isNumber(spec.grow) ||
+            isNumber(spec.minPx) ||
+            isNumber(spec.maxPx))
+    );
 }
 
 /**
@@ -290,7 +320,8 @@ export function parseSizeDef(size) {
     if (isStepSize(size)) {
         throw new Error("parseSizeDef does not accept step-based sizes.");
     } else if (isSizeDef(size)) {
-        return size;
+        validateSizeDef(size);
+        return createSizeDef(size);
     } else if (isNumber(size)) {
         return { px: size, grow: 0 };
     } else if (size === "container") {
@@ -302,3 +333,272 @@ export function parseSizeDef(size) {
 
     throw new Error(`Invalid sizeDef: ${size}`);
 }
+
+/**
+ * Resolves final item sizes using GenomeSpy's simplified flex model. It is
+ * inspired by CSS Flexbox §9.7 "Resolving Flexible Lengths", but only covers
+ * grow-based free-space distribution and min/max constraints.
+ *
+ * https://www.w3.org/TR/css-flexbox-1/#resolve-flexible-lengths
+ *
+ * @param {SizeDef[]} items
+ * @param {number} containerSize
+ * @param {number} spacing
+ * @returns {number[]}
+ */
+function resolveItemSizes(items, containerSize, spacing) {
+    let hasConstraints = false;
+    for (const item of items) {
+        validateSizeDef(item);
+        hasConstraints ||= hasSizeConstraints(item);
+    }
+
+    if (!hasConstraints) {
+        return resolveUnconstrainedItemSizes(items, containerSize, spacing);
+    }
+
+    /** @type {number[]} */
+    const sizes = Array(items.length).fill(0);
+    /** @type {number[]} */
+    const flexIndices = [];
+    for (let i = 0; i < items.length; i++) {
+        if (!isZeroSizeDef(items[i])) {
+            flexIndices.push(i);
+        }
+    }
+
+    const gapSize = Math.max(0, flexIndices.length - 1) * spacing;
+    const availableSize = Math.max(0, containerSize - gapSize);
+
+    // Fixed-size items do not participate in flex growth, but min/max still
+    // clamp them just like flex items with flex-grow: 0.
+    /** @type {Set<number>} */
+    const frozen = new Set();
+
+    for (const index of flexIndices) {
+        const item = items[index];
+        if (!z(item.grow)) {
+            sizes[index] = clampSize(z(item.px), item);
+            frozen.add(index);
+        }
+    }
+
+    while (true) {
+        let totalBase = 0;
+        let totalGrow = 0;
+        let frozenSize = 0;
+
+        // Frozen items have their final size. Unfrozen items still contribute
+        // their base px size and grow factor to the next free-space pass.
+        for (const index of flexIndices) {
+            if (frozen.has(index)) {
+                frozenSize += sizes[index];
+            } else {
+                totalBase += z(items[index].px);
+                totalGrow += z(items[index].grow);
+            }
+        }
+
+        if (!totalGrow) {
+            for (const index of flexIndices) {
+                if (!frozen.has(index)) {
+                    sizes[index] = clampSize(z(items[index].px), items[index]);
+                    frozen.add(index);
+                }
+            }
+            break;
+        }
+
+        const remainingSize = Math.max(
+            0,
+            availableSize - frozenSize - totalBase
+        );
+        let totalViolation = 0;
+        /** @type {number[]} */
+        const minViolations = [];
+        /** @type {number[]} */
+        const maxViolations = [];
+
+        // CSS Flexbox §9.7 first clamps every unfrozen item, then uses the
+        // aggregate violation to decide which side freezes. We follow that
+        // part so mixed min/max violations converge the same way.
+        for (const index of flexIndices) {
+            if (frozen.has(index)) {
+                continue;
+            }
+
+            const item = items[index];
+            const targetSize =
+                z(item.px) + (z(item.grow) / totalGrow) * remainingSize;
+            const clampedSize = clampSize(targetSize, item);
+            sizes[index] = clampedSize;
+
+            const violation = clampedSize - targetSize;
+            totalViolation += violation;
+            if (violation > 0) {
+                minViolations.push(index);
+            } else if (violation < 0) {
+                maxViolations.push(index);
+            }
+        }
+
+        if (!minViolations.length && !maxViolations.length) {
+            break;
+        } else if (totalViolation > 0) {
+            for (const index of minViolations) {
+                frozen.add(index);
+            }
+        } else if (totalViolation < 0) {
+            for (const index of maxViolations) {
+                frozen.add(index);
+            }
+        } else {
+            for (const index of flexIndices) {
+                frozen.add(index);
+            }
+        }
+    }
+
+    return sizes;
+}
+
+/**
+ * Fast path for the common SizeDef shape that only uses px and grow.
+ *
+ * @param {SizeDef[]} items
+ * @param {number} containerSize
+ * @param {number} spacing
+ * @returns {number[]}
+ */
+function resolveUnconstrainedItemSizes(items, containerSize, spacing) {
+    let totalPx = 0;
+    let totalGrow = 0;
+
+    for (const size of items) {
+        totalPx += z(size.px) + (isZeroSizeDef(size) ? 0 : spacing);
+        totalGrow += z(size.grow);
+    }
+    totalPx -= spacing;
+
+    const remainingSpace = Math.max(0, containerSize - totalPx);
+
+    /** @type {number[]} */
+    const sizes = Array(items.length);
+    for (let i = 0; i < items.length; i++) {
+        const size = items[i];
+        sizes[i] = isZeroSizeDef(size)
+            ? 0
+            : z(size.px) +
+              (totalGrow ? (z(size.grow) / totalGrow) * remainingSpace : 0);
+    }
+
+    return sizes;
+}
+
+/**
+ * @param {SizeDef} size
+ */
+function validateSizeDef(size) {
+    if (
+        size.minPx !== undefined &&
+        size.maxPx !== undefined &&
+        size.minPx > size.maxPx
+    ) {
+        throw new Error("SizeDef minPx cannot be greater than maxPx.");
+    }
+}
+
+/**
+ * @param {number} size
+ * @param {SizeDef} sizeDef
+ */
+function clampSize(size, sizeDef) {
+    return Math.min(
+        Math.max(size, sizeDef.minPx ?? 0),
+        sizeDef.maxPx ?? Infinity
+    );
+}
+
+/**
+ * @param {SizeDef} sizeDef
+ */
+export function getSizeDefMinPx(sizeDef) {
+    return clampSize(z(sizeDef.px), sizeDef);
+}
+
+/**
+ * @param {SizeDef} sizeDef
+ * @returns {number | undefined}
+ */
+export function getSizeDefMaxPx(sizeDef) {
+    return (
+        sizeDef.maxPx ??
+        (z(sizeDef.grow) ? undefined : getSizeDefMinPx(sizeDef))
+    );
+}
+
+/**
+ * @param {SizeDef} sizeDef
+ */
+function hasSizeConstraints(sizeDef) {
+    return sizeDef.minPx !== undefined || sizeDef.maxPx !== undefined;
+}
+
+/**
+ * @param {SizeDef} sizeDef
+ * @param {number} px
+ * @returns {SizeDef}
+ */
+function addPxToSizeDef(sizeDef, px) {
+    return createSizeDef({
+        px: (sizeDef.px ?? 0) + px,
+        grow: sizeDef.grow,
+        minPx:
+            sizeDef.minPx === undefined
+                ? undefined
+                : Math.max(0, sizeDef.minPx + px),
+        maxPx:
+            sizeDef.maxPx === undefined
+                ? undefined
+                : Math.max(0, sizeDef.maxPx + px),
+    });
+}
+
+/**
+ * @param {SizeDef} sizeDef
+ * @returns {SizeDef}
+ */
+function createSizeDef(sizeDef) {
+    /** @type {SizeDef} */
+    const result = {};
+    const hasPx = sizeDef.px !== undefined;
+    const hasGrow = sizeDef.grow !== undefined;
+    const hasConstraints = hasSizeConstraints(sizeDef);
+
+    if (sizeDef.px) {
+        result.px = sizeDef.px;
+    } else if (sizeDef.px === 0) {
+        result.px = 0;
+    }
+
+    if (sizeDef.grow) {
+        result.grow = sizeDef.grow;
+    } else if (sizeDef.grow === 0) {
+        result.grow = 0;
+    } else if (!hasPx && !hasGrow && hasConstraints) {
+        result.grow = 1;
+    }
+
+    if (sizeDef.minPx && sizeDef.minPx > z(sizeDef.px)) {
+        result.minPx = sizeDef.minPx;
+    }
+
+    if (
+        sizeDef.maxPx !== undefined &&
+        (z(result.grow) || sizeDef.maxPx < z(sizeDef.px))
+    ) {
+        result.maxPx = sizeDef.maxPx;
+    }
+
+    return result;
+}

package/dist/src/view/layout/rectangle.d.ts

@@ -95,6 +95,20 @@ export default class Rectangle {
      * @param {Rectangle} rectangle
      */
     intersect(rectangle: Rectangle): Rectangle;
+    /**
+     * Returns an intersection of this and the other's x range. The y range is
+     * preserved.
+     *
+     * @param {Rectangle} rectangle
+     */
+    intersectX(rectangle: Rectangle): Rectangle;
+    /**
+     * Returns an intersection of this and the other's y range. The x range is
+     * preserved.
+     *
+     * @param {Rectangle} rectangle
+     */
+    intersectY(rectangle: Rectangle): Rectangle;
     /**
      * Returns an union of this and the other rectangle.
      *

package/dist/src/view/layout/rectangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangle.d.ts","sourceRoot":"","sources":["../../../../src/view/layout/rectangle.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH;IACI;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,aAShB;IAED,uBAA2C;IA+B3C;;;;;;OAMG;IACH,eALW,QAAQ,KACR,QAAQ,SACR,QAAQ,UACR,QAAQ,EAOlB;IAzCD;;;;OAIG;IACH,cAJW,IAAI,SACJ,MAAM,IAAG,MAAW,MAAM,CAAA,GACxB,QAAQ,CAiBpB;IAED;;OAEG;IACH,mBAFW,IAAI,YAId;IAUG,gBAAgB,CAAC,sBAAW;IAC5B,gBAAgB,CAAC,sBAAW;IAC5B,gBAAgB,CAAC,0BAAmB;IACpC,gBAAgB,CAAC,2BAAqB;IAG1C;;OAEG;IACH,SAFa,MAAM,CAIlB;IAED;;OAEG;IACH,SAFa,MAAM,CAIlB;IAED;;OAEG;IACH,aAFa,MAAM,CAIlB;IAED;;OAEG;IACH,cAFa,MAAM,CAIlB;IAED,iBAEC;IAED,iBAEC;IAED;;;;OAIG;IACH,kBAFW,SAAS,WAcnB;IAED;;;OAGG;IACH,cAFW,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,IAAG,MAAW,MAAM,CAAA,CAAC,CAAC,aAkB3D;IAED;;;;OAIG;IACH,aAHW,MAAM,IAAG,MAAW,MAAM,CAAA,KAC1B,MAAM,IAAG,MAAW,MAAM,CAAA,aAapC;IAED;;;;OAIG;IACH,uBAFW,SAAS,aAKnB;IAED;;;OAGG;IACH,gBAFW,OAAO,iCA0BjB;IAED;;;OAGG;IACH,gBAFW,OAAO,aAIjB;IAED;;;;OAIG;IACH,qBAFW,SAAS,aAenB;IAED;;;;OAIG;IACH,iBAFW,SAAS,aAenB;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,qBAOC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,KACN,MAAM,WAIhB;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,KACN,MAAM,UACN,OAAO;;;MAWjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,KACN,MAAM,UACN,OAAO;;;MAUjB;IAED,mBAEC;IAED,0BAMC;CACJ;;;;;mBAnUY,CAAC,GAAG,GAAG,GAAG,GAAG,OAAO,GAAG,QAAQ,CAAC;;;;;sBAChC,OAAO,cAAc,EAAE,OAAO;;;;;uBAC9B,MAAM,MAAM"}
+{"version":3,"file":"rectangle.d.ts","sourceRoot":"","sources":["../../../../src/view/layout/rectangle.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH;IACI;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,aAShB;IAED,uBAA2C;IA+B3C;;;;;;OAMG;IACH,eALW,QAAQ,KACR,QAAQ,SACR,QAAQ,UACR,QAAQ,EAOlB;IAzCD;;;;OAIG;IACH,cAJW,IAAI,SACJ,MAAM,IAAG,MAAW,MAAM,CAAA,GACxB,QAAQ,CAiBpB;IAED;;OAEG;IACH,mBAFW,IAAI,YAId;IAUG,gBAAgB,CAAC,sBAAW;IAC5B,gBAAgB,CAAC,sBAAW;IAC5B,gBAAgB,CAAC,0BAAmB;IACpC,gBAAgB,CAAC,2BAAqB;IAG1C;;OAEG;IACH,SAFa,MAAM,CAIlB;IAED;;OAEG;IACH,SAFa,MAAM,CAIlB;IAED;;OAEG;IACH,aAFa,MAAM,CAIlB;IAED;;OAEG;IACH,cAFa,MAAM,CAIlB;IAED,iBAEC;IAED,iBAEC;IAED;;;;OAIG;IACH,kBAFW,SAAS,WAcnB;IAED;;;OAGG;IACH,cAFW,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,IAAG,MAAW,MAAM,CAAA,CAAC,CAAC,aAkB3D;IAED;;;;OAIG;IACH,aAHW,MAAM,IAAG,MAAW,MAAM,CAAA,KAC1B,MAAM,IAAG,MAAW,MAAM,CAAA,aAapC;IAED;;;;OAIG;IACH,uBAFW,SAAS,aAKnB;IAED;;;OAGG;IACH,gBAFW,OAAO,iCA0BjB;IAED;;;OAGG;IACH,gBAFW,OAAO,aAIjB;IAED;;;;OAIG;IACH,qBAFW,SAAS,aAenB;IAED;;;;;OAKG;IACH,sBAFW,SAAS,aAcnB;IAED;;;;;OAKG;IACH,sBAFW,SAAS,aAcnB;IAED;;;;OAIG;IACH,iBAFW,SAAS,aAenB;IAED;;OAEG;IACH,qBAEC;IAED;;;OAGG;IACH,qBAOC;IAED;;;;;OAKG;IACH,iBAHW,MAAM,KACN,MAAM,WAIhB;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,KACN,MAAM,UACN,OAAO;;;MAWjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,KACN,MAAM,UACN,OAAO;;;MAUjB;IAED,mBAEC;IAED,0BAMC;CACJ;;;;;mBA3WY,CAAC,GAAG,GAAG,GAAG,GAAG,OAAO,GAAG,QAAQ,CAAC;;;;;sBAChC,OAAO,cAAc,EAAE,OAAO;;;;;uBAC9B,MAAM,MAAM"}

package/dist/src/view/layout/rectangle.js

@@ -239,6 +239,46 @@ export default class Rectangle {
         );
     }
 
+    /**
+     * Returns an intersection of this and the other's x range. The y range is
+     * preserved.
+     *
+     * @param {Rectangle} rectangle
+     */
+    intersectX(rectangle) {
+        if (this === rectangle || rectangle == null) {
+            return this;
+        }
+
+        return new Rectangle(
+            () => Math.max(this.x, rectangle.x),
+            this._passThrough("y"),
+            () =>
+                Math.min(this.x2, rectangle.x2) - Math.max(this.x, rectangle.x),
+            this._passThrough("height")
+        );
+    }
+
+    /**
+     * Returns an intersection of this and the other's y range. The x range is
+     * preserved.
+     *
+     * @param {Rectangle} rectangle
+     */
+    intersectY(rectangle) {
+        if (this === rectangle || rectangle == null) {
+            return this;
+        }
+
+        return new Rectangle(
+            this._passThrough("x"),
+            () => Math.max(this.y, rectangle.y),
+            this._passThrough("width"),
+            () =>
+                Math.min(this.y2, rectangle.y2) - Math.max(this.y, rectangle.y)
+        );
+    }
+
     /**
      * Returns an union of this and the other rectangle.
      *

package/dist/src/view/legend/legendEntries.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @typedef {object} LegendEntry
+ * @prop {string | number | boolean} value
+ * @prop {string} label
+ * @prop {number} _legendIndex
+ */
+/**
+ * Creates symbol legend entries from a discrete scale resolution.
+ *
+ * @param {Pick<import("../../scales/scaleResolution.js").default, "getDomain">} resolution
+ * @param {(value: import("../../spec/channel.js").Scalar) => string} [format]
+ * @returns {LegendEntry[]}
+ */
+export function createDiscreteLegendEntries(resolution: Pick<import("../../scales/scaleResolution.js").default, "getDomain">, format?: (value: import("../../spec/channel.js").Scalar) => string): LegendEntry[];
+export type LegendEntry = {
+    value: string | number | boolean;
+    label: string;
+    _legendIndex: number;
+};
+//# sourceMappingURL=legendEntries.d.ts.map

package/dist/src/view/legend/legendEntries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legendEntries.d.ts","sourceRoot":"","sources":["../../../../src/view/legend/legendEntries.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wDAJW,IAAI,CAAC,OAAO,iCAAiC,EAAE,OAAO,EAAE,WAAW,CAAC,WACpE,CAAC,KAAK,EAAE,OAAO,uBAAuB,EAAE,MAAM,KAAK,MAAM,GACvD,WAAW,EAAE,CAQzB;;WAlBS,MAAM,GAAG,MAAM,GAAG,OAAO;WACzB,MAAM;kBACN,MAAM"}

package/dist/src/view/legend/legendEntries.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {object} LegendEntry
+ * @prop {string | number | boolean} value
+ * @prop {string} label
+ * @prop {number} _legendIndex
+ */
+
+/**
+ * Creates symbol legend entries from a discrete scale resolution.
+ *
+ * @param {Pick<import("../../scales/scaleResolution.js").default, "getDomain">} resolution
+ * @param {(value: import("../../spec/channel.js").Scalar) => string} [format]
+ * @returns {LegendEntry[]}
+ */
+export function createDiscreteLegendEntries(resolution, format = String) {
+    return resolution.getDomain().map((value, index) => ({
+        value,
+        label: format(value),
+        _legendIndex: index,
+    }));
+}