@milaboratories/miplots4 1.0.123 → 1.0.125

package/dist/discrete/layers/binnedDots.d.ts

@@ -0,0 +1,28 @@
+import { GroupKey, NO_GROUPED, DataFrame } from '../../DataFrame';
+import { BinnedDotsLayer, DiscreteSettingsImpl } from '../DiscreteSettingsImpl';
+import { BinnedDotsData } from './types';
+import { ColumnName, DataValue, Row } from '../../types';
+export declare class BinnedDots {
+    bins: {
+        x: number;
+        count: number;
+        dots: {
+            key: string;
+            value: number;
+        }[];
+    }[];
+    primaryGrouping: string;
+    secondaryGrouping: string;
+    key: string;
+    boundsY: {
+        min: number;
+        max: number;
+    };
+    constructor(valueRows: Row[], valueColumn: string, primaryGrouping: DataValue | typeof NO_GROUPED, secondaryGrouping: DataValue | typeof NO_GROUPED, step: number, convertToScale: (v: number) => number, convertFromScale: (v: number) => number, yGetter: (r: Row) => number, scale: 'log' | 'linear', keyColumn: ColumnName | null);
+}
+export declare function getBinnedDotsData(layer: BinnedDotsLayer, groupingKeys: {
+    facet: GroupKey[][];
+    primary: GroupKey[];
+    secondary: GroupKey[];
+}, data: DataFrame, y: DiscreteSettingsImpl['y'], yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']): BinnedDotsData;
+//# sourceMappingURL=binnedDots.d.ts.map

package/dist/discrete/layers/binnedDots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binnedDots.d.ts","sourceRoot":"","sources":["../../../src/discrete/layers/binnedDots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,SAAS,CAAC;AAG5C,OAAO,KAAK,EAAC,UAAU,EAAE,SAAS,EAAE,GAAG,EAAC,MAAM,aAAa,CAAC;AAmD5D,qBAAa,UAAU;IACnB,IAAI,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,EAAE,CAAA;KAAC,EAAE,CAAC;IACzE,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IAEZ,OAAO,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;gBAGE,SAAS,EAAE,GAAG,EAAE,EAChB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,SAAS,GAAG,OAAO,UAAU,EAC9C,iBAAiB,EAAE,SAAS,GAAI,OAAO,UAAU,EACjD,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACrC,gBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACvC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,MAAM,EAC3B,KAAK,EAAE,KAAK,GAAG,QAAQ,EACvB,SAAS,EAAE,UAAU,GAAG,IAAI;CAwBnC;AAED,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,eAAe,EACtB,YAAY,EAAE;IACV,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACxB,EACD,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,EAC5B,KAAK,EAAE,oBAAoB,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,GACtD,cAAc,CAyEhB"}

package/dist/discrete/layers/binnedDots.js

@@ -0,0 +1,106 @@
+var N = Object.defineProperty;
+var R = (e, o, u) => o in e ? N(e, o, { enumerable: !0, configurable: !0, writable: !0, value: u }) : e[o] = u;
+var b = (e, o, u) => R(e, typeof o != "symbol" ? o + "" : o, u);
+import { getOutliersBounds as k } from "../utils/getOutliersBounds.js";
+import { getFacetStringKey as S } from "../utils/getFacetStringKey.js";
+import _ from "../../node_modules/d3-array/src/extent.js";
+const B = 30;
+function $(e, o, u, a, c, f) {
+  const i = e.map((n) => u(c(n))), r = e.length, l = e.map(d), h = [];
+  function d(n, m) {
+    return { key: f(n, m), value: c(n) };
+  }
+  let s = 0;
+  for (let n = 1; n < r; ++n) {
+    const m = i[s], D = i[n], t = i[n - 1];
+    if (D >= m + o) {
+      const g = Math.min((m + t) / 2, D - o);
+      i.fill(g, s, n), h.push({
+        x: a(g),
+        count: n - s,
+        dots: l.slice(s, n)
+      }), s = n;
+    }
+  }
+  return i.fill((i[s] + i[r - 1]) / 2, s, r), h.push({
+    x: a((i[s] + i[r - 1]) / 2),
+    count: r - s,
+    dots: l.slice(s, r)
+  }), h;
+}
+class E {
+  constructor(o, u, a, c, f, i, r, l, h, d) {
+    b(this, "bins");
+    b(this, "primaryGrouping");
+    b(this, "secondaryGrouping");
+    b(this, "key");
+    b(this, "boundsY");
+    this.primaryGrouping = String(a), this.secondaryGrouping = String(c), this.key = `binnedDots_${this.primaryGrouping}_${this.secondaryGrouping}`;
+    const s = o.filter((n) => l(n) === 0 && h === "log" ? (console.warn(`Item with ${u} = 0 is not shown on chart with log scale`), !1) : !0).sort((n, m) => i(l(n)) - i(l(m)));
+    this.bins = $(
+      s,
+      f,
+      i,
+      r,
+      l,
+      (n, m) => String(d ? n[d.value] : m)
+    ), this.boundsY = {
+      min: this.bins[0].x,
+      max: this.bins[this.bins.length - 1].x
+    };
+  }
+}
+function P(e, o, u, a, c) {
+  const f = (t) => c.scale === "log" ? Math.log10(t) : t, i = (t) => c.scale === "log" ? Math.pow(10, t) : t, r = (t) => Number(t[a.value]);
+  let l = 1 / 0, h = -1 / 0;
+  const d = u.getRowsByGrouping([]), [s = r(d[0]), n = r(d[0])] = _(
+    d.filter((t) => Number(t[a.value]) === 0 && c.scale === "log" ? (console.warn(`Item with ${a.value} = 0 is not shown on chart with log scale`), !1) : !0),
+    (t) => Number(t[a.value])
+  ), m = Math.abs(f(s) - f(n)) / B;
+  return {
+    type: "binnedDots",
+    geoms: o.facet.reduce((t, g) => {
+      const x = S(g);
+      return t[x] = [], o.primary.forEach((Y) => {
+        o.secondary.forEach((G) => {
+          const w = u.getRowsByGrouping([...g, Y, G]);
+          if (!w.length)
+            return;
+          let M = w;
+          if (!e.aes.showOutliers) {
+            const [C, F] = k(w, c.scale, r);
+            M = w.filter((I) => {
+              const v = r(I);
+              return v >= C && v <= F;
+            });
+          }
+          const p = new E(
+            M,
+            a.value,
+            Y,
+            G,
+            m,
+            f,
+            i,
+            r,
+            c.scale,
+            e.keyColumn
+          );
+          p.boundsY.min < l && (l = p.boundsY.min), p.boundsY.max > h && (h = p.boundsY.max), t[x].push(p);
+        });
+      }), t;
+    }, {}),
+    meta: {
+      minY: Math.min(s, n, l),
+      maxY: Math.max(s, n, h),
+      binsCount: B,
+      hasKeyFromColumn: e.keyColumn !== null
+    },
+    aes: e.aes
+  };
+}
+export {
+  E as BinnedDots,
+  P as getBinnedDotsData
+};
+//# sourceMappingURL=binnedDots.js.map

package/dist/discrete/layers/binnedDots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binnedDots.js","sources":["../../../src/discrete/layers/binnedDots.ts"],"sourcesContent":["import type {GroupKey, NO_GROUPED} from '../../DataFrame';\nimport type {DataFrame} from '../../DataFrame';\nimport type {BinnedDotsLayer} from '../DiscreteSettingsImpl';\nimport type {DiscreteSettingsImpl} from '../DiscreteSettingsImpl';\nimport type {BinnedDotsData} from './types';\nimport {getOutliersBounds} from '../utils';\nimport {getFacetStringKey} from '../utils/getFacetStringKey';\nimport type {ColumnName, DataValue, Row} from '../../types';\nimport {extent} from 'd3-array';\n\nconst DEFAULT_BINS_COUNT = 30;\n\nfunction dotbin(\n    data: Row[],\n    step: number,\n    convertToScale: (v: number) => number,\n    convertFromScale: (v: number) => number,\n    valueGetter: (row: Row) => number,\n    keyGetter: (row: Row, idx: number) => string\n) {\n    const x = data.map(r => convertToScale(valueGetter(r))); // make a protective copy\n    const n = data.length;\n    const dotData = data.map(getDotData);\n    const result: {x: number; count: number; dots: {key: string; value: number}[]}[] = [];\n\n    function getDotData(row: Row, idx: number) {\n        return {key: keyGetter(row, idx), value: valueGetter(row)};\n    }\n\n    let left = 0; // left index of the current bin\n\n    // scan from left, group points less than one step away\n    for (let j = 1; j < n; ++j) {\n        const scaledLeft = x[left];\n        const scaledCurrent = x[j];\n        const scaledPrev = x[j - 1];\n        if (scaledCurrent >= scaledLeft + step) {\n            // use span mid-point, unless that could cause overlap\n            const xmid = Math.min((scaledLeft + scaledPrev) / 2, scaledCurrent - step);\n            x.fill(xmid, left, j);\n            result.push({\n                x: convertFromScale(xmid),\n                count: j - left,\n                dots: dotData.slice(left, j),\n            });\n            left = j;\n        }\n    }\n    x.fill((x[left] + x[n - 1]) / 2, left, n);\n    result.push({\n        x: convertFromScale((x[left] + x[n - 1]) / 2),\n        count: n - left,\n        dots: dotData.slice(left, n),\n    });\n\n    return result;\n}\n\nexport class BinnedDots {\n    bins: {x: number; count: number; dots: {key: string; value: number}[]}[];\n    primaryGrouping: string;\n    secondaryGrouping: string;\n    key: string;\n\n    boundsY: {\n        min: number;\n        max: number;\n    };\n\n    constructor(\n        valueRows: Row[],\n        valueColumn: string,\n        primaryGrouping: DataValue | typeof NO_GROUPED,\n        secondaryGrouping: DataValue |  typeof NO_GROUPED,\n        step: number,\n        convertToScale: (v: number) => number,\n        convertFromScale: (v: number) => number,\n        yGetter: (r: Row) => number,\n        scale: 'log' | 'linear',\n        keyColumn: ColumnName | null\n    ) {\n        this.primaryGrouping = String(primaryGrouping);\n        this.secondaryGrouping = String(secondaryGrouping);\n        this.key = `binnedDots_${this.primaryGrouping}_${this.secondaryGrouping}`;\n\n        const sortedGroup = valueRows\n            .filter(row => {\n                if (yGetter(row) === 0 && scale === 'log') {\n                    console.warn(`Item with ${valueColumn} = 0 is not shown on chart with log scale`);\n                    return false;\n                }\n                return true;\n            })\n            .sort((a, b) => convertToScale(yGetter(a)) - convertToScale(yGetter(b)));\n\n        this.bins = dotbin(sortedGroup, step, convertToScale, convertFromScale, yGetter, (row: Row, idx: number) =>\n            String(keyColumn ? row[keyColumn.value] : idx)\n        );\n        this.boundsY = {\n            min: this.bins[0].x,\n            max: this.bins[this.bins.length - 1].x,\n        };\n    }\n}\n\nexport function getBinnedDotsData(\n    layer: BinnedDotsLayer,\n    groupingKeys: {\n        facet: GroupKey[][],\n        primary: GroupKey[],\n        secondary: GroupKey[]\n    },\n    data: DataFrame,\n    y: DiscreteSettingsImpl['y'],\n    yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']\n): BinnedDotsData {\n    const convertToScale = (v: number) => (yAxis.scale === 'log' ? Math.log10(v) : v);\n    const convertFromScale = (v: number) => (yAxis.scale === 'log' ? Math.pow(10, v) : v);\n    const yGetter = (row: Row) => Number(row[y.value]);\n    let minY = Infinity;\n    let maxY = -Infinity;\n\n    const allRows = data.getRowsByGrouping([]);\n    const [bound1 = yGetter(allRows[0]), bound2 = yGetter(allRows[0])] = extent(\n        allRows.filter(row => {\n            if (Number(row[y.value]) === 0 && yAxis.scale === 'log') {\n                console.warn(`Item with ${y.value} = 0 is not shown on chart with log scale`);\n                return false;\n            }\n            return true;\n        }),\n        row => Number(row[y.value])\n    );\n    const step = Math.abs(convertToScale(bound1) - convertToScale(bound2)) / DEFAULT_BINS_COUNT;\n\n    const binnedDotsGroups = groupingKeys.facet.reduce((res: Record<string, BinnedDots[]>, facetKey) => {\n        const strFacetKey = getFacetStringKey(facetKey);\n        res[strFacetKey] = [];\n        groupingKeys.primary.forEach(primaryKey => {\n            groupingKeys.secondary.forEach(secondaryKey => {\n                const valueRows = data.getRowsByGrouping([...facetKey, primaryKey, secondaryKey]);\n                if (!valueRows.length) {\n                    return;\n                }\n                let valueRowsFiltered = valueRows;\n                if (!layer.aes.showOutliers) {\n                    const [boundsMin, boundMax] = getOutliersBounds(valueRows, yAxis.scale, yGetter);\n                    valueRowsFiltered = valueRows.filter((row: Row) => {\n                        const value = yGetter(row);\n                        return value >= boundsMin && value <= boundMax;\n                    });\n                }\n                const binnedDots = new BinnedDots(\n                    valueRowsFiltered,\n                    y.value,\n                    primaryKey,\n                    secondaryKey,\n                    step,\n                    convertToScale,\n                    convertFromScale,\n                    yGetter,\n                    yAxis.scale,\n                    layer.keyColumn\n                );\n\n                if (binnedDots.boundsY.min < minY) {\n                    minY = binnedDots.boundsY.min;\n                }\n                if (binnedDots.boundsY.max > maxY) {\n                    maxY = binnedDots.boundsY.max;\n                }\n                res[strFacetKey].push(binnedDots);\n            });\n        });\n        return res;\n    }, {});\n\n    return {\n        type: 'binnedDots',\n        geoms: binnedDotsGroups,\n        meta: {\n            minY: Math.min(bound1, bound2, minY),\n            maxY: Math.max(bound1, bound2, maxY),\n            binsCount: DEFAULT_BINS_COUNT,\n            hasKeyFromColumn: layer.keyColumn !== null,\n        },\n        aes: layer.aes,\n    };\n}\n"],"names":["DEFAULT_BINS_COUNT","dotbin","data","step","convertToScale","convertFromScale","valueGetter","keyGetter","x","r","n","dotData","getDotData","result","row","idx","left","j","scaledLeft","scaledCurrent","scaledPrev","xmid","BinnedDots","valueRows","valueColumn","primaryGrouping","secondaryGrouping","yGetter","scale","keyColumn","__publicField","sortedGroup","a","b","getBinnedDotsData","layer","groupingKeys","y","yAxis","v","minY","maxY","allRows","bound1","bound2","extent","res","facetKey","strFacetKey","getFacetStringKey","primaryKey","secondaryKey","valueRowsFiltered","boundsMin","boundMax","getOutliersBounds","value","binnedDots"],"mappings":"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"}

package/dist/discrete/layers/boxes.d.ts

@@ -0,0 +1,30 @@
+import { NO_GROUPED, DataFrame, GroupKey } from '../../DataFrame';
+import { BoxLayer, DiscreteSettingsImpl } from '../DiscreteSettingsImpl';
+import { BoxesData } from './types';
+import { ColumnName, DataValue, Row } from '../../types';
+export declare class Box {
+    lower: number;
+    middle: number;
+    upper: number;
+    min: number;
+    max: number;
+    outliers: {
+        y: number;
+        id: string;
+        data: Row;
+    }[];
+    primaryGrouping: GroupKey;
+    secondaryGrouping: GroupKey;
+    key: string;
+    boundsY: {
+        min: number;
+        max: number;
+    };
+    constructor(valuesRows: Row[], valueColumn: string, keyColumn: string | null, scale: 'linear' | 'log', primaryGrouping: DataValue | typeof NO_GROUPED, secondaryGrouping: DataValue | typeof NO_GROUPED, lower: number, middle: number, upper: number, k: number, showOutliers?: boolean);
+}
+export declare function getBoxesData(layer: BoxLayer, groupingKeys: {
+    facet: GroupKey[][];
+    primary: GroupKey[];
+    secondary: GroupKey[];
+}, data: DataFrame, y: ColumnName, keyColumn: ColumnName | null, yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']): BoxesData;
+//# sourceMappingURL=boxes.d.ts.map

package/dist/discrete/layers/boxes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxes.d.ts","sourceRoot":"","sources":["../../../src/discrete/layers/boxes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAC,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAC,SAAS,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAC,QAAQ,EAAE,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAC5E,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAC;AAGvC,OAAO,KAAK,EAAC,UAAU,EAAE,SAAS,EAAE,GAAG,EAAC,MAAM,aAAa,CAAC;AAe5D,qBAAa,GAAG;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE;QACN,CAAC,EAAE,MAAM,CAAC;QACV,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,GAAG,CAAC;KACb,EAAE,CAAC;IAGJ,eAAe,EAAE,QAAQ,CAAC;IAC1B,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,GAAG,EAAE,MAAM,CAAC;IAGZ,OAAO,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;gBAGE,UAAU,EAAE,GAAG,EAAE,EACjB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,KAAK,EAAE,QAAQ,GAAG,KAAK,EACvB,eAAe,EAAE,SAAS,GAAG,OAAO,UAAU,EAC9C,iBAAiB,EAAE,SAAS,GAAG,OAAO,UAAU,EAChD,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,CAAC,EAAE,MAAM,EACT,YAAY,UAAO;CAiD1B;AAED,wBAAgB,YAAY,CACxB,KAAK,EAAE,QAAQ,EACf,YAAY,EAAE;IACV,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACxB,EACD,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,UAAU,EACb,SAAS,EAAE,UAAU,GAAG,IAAI,EAC5B,KAAK,EAAE,oBAAoB,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,GACtD,SAAS,CA0CX"}

package/dist/discrete/layers/boxes.js

@@ -0,0 +1,91 @@
+var y = Object.defineProperty;
+var q = (o, t, n) => t in o ? y(o, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : o[t] = n;
+var a = (o, t, n) => q(o, typeof t != "symbol" ? t + "" : t, n);
+import { getFacetStringKey as v } from "../utils/getFacetStringKey.js";
+import w from "../../node_modules/lodash/lodash.js";
+import { quantileSorted as G } from "../../node_modules/d3-array/src/quantile.js";
+import B from "../../node_modules/d3-array/src/min.js";
+import F from "../../node_modules/d3-array/src/max.js";
+import O from "../../node_modules/d3-array/src/extent.js";
+function V(o, t, n, d = !1) {
+  const s = o.map(t).sort((h, r) => h - r);
+  if (d) {
+    const h = w.find(s, (r) => r > 0);
+    if (!h)
+      throw Error("Group with all zeros in log scale");
+    return s.map((r) => r === 0 ? h : r).map(n);
+  }
+  return s.map(n);
+}
+class _ {
+  constructor(t, n, d, s, h, r, u, c, f, p, l = !0) {
+    a(this, "lower");
+    a(this, "middle");
+    a(this, "upper");
+    a(this, "min");
+    a(this, "max");
+    a(this, "outliers");
+    // Saved data for linking with visual properties (set color by grouping etc.)
+    a(this, "primaryGrouping");
+    a(this, "secondaryGrouping");
+    a(this, "key");
+    // Bounds for correct chart viewport
+    a(this, "boundsY");
+    if (t.length === 0)
+      throw Error("Unable to create box on empty data");
+    if (u > c || u > f || c > f)
+      throw Error(`Invalid box bounds values: lower=${u}, middle=${c}, upper=${f}`);
+    if (p < 0)
+      throw Error(`Invalid box whiskers coefficient: k=${p}. It should be positive`);
+    const m = (i) => Number(i[n]);
+    this.primaryGrouping = String(h), this.secondaryGrouping = String(r), this.key = `box_${this.primaryGrouping}_${this.secondaryGrouping}`;
+    const x = (i) => s === "log" ? Math.log10(i) : i, e = (i) => s === "log" ? Math.pow(10, i) : i, g = V(t, m, x, s === "log"), b = G(g, u), I = G(g, c), S = G(g, f), Y = S - b;
+    this.upper = e(S), this.middle = e(I), this.lower = e(b), this.min = Math.max(B(t, m), e(b - p * Y)), this.max = Math.min(F(t, m), e(S + p * Y)), this.outliers = t.filter((i) => m(i) < this.min || m(i) > this.max).map((i, $) => ({
+      y: m(i),
+      data: i,
+      id: String(d ? i[d] : $)
+    }));
+    const [M = 1 / 0, E = -1 / 0] = O(this.outliers, (i) => i.y);
+    this.boundsY = {
+      min: l ? Math.min(this.min, M) : this.min,
+      max: l ? Math.max(this.max, E) : this.max
+    };
+  }
+}
+function j(o, t, n, d, s, h) {
+  let r = 1 / 0, u = -1 / 0;
+  return {
+    type: "box",
+    geoms: t.facet.reduce((c, f) => {
+      const p = v(f);
+      return c[p] = [], t.primary.forEach((l) => {
+        t.secondary.forEach((m) => {
+          const x = n.getRowsByGrouping([...f, l, m]);
+          if (!x.length)
+            return;
+          const e = new _(
+            x,
+            d.value,
+            (s == null ? void 0 : s.value) ?? null,
+            h.scale,
+            l,
+            m,
+            o.stat.lower,
+            o.stat.medium,
+            o.stat.upper,
+            o.stat.k,
+            o.aes.showOutliers
+          );
+          e.boundsY.min < r && (r = e.boundsY.min), e.boundsY.max > u && (u = e.boundsY.max), c[p].push(e);
+        });
+      }), c;
+    }, {}),
+    meta: { minY: r, maxY: u },
+    aes: o.aes
+  };
+}
+export {
+  _ as Box,
+  j as getBoxesData
+};
+//# sourceMappingURL=boxes.js.map

package/dist/discrete/layers/boxes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxes.js","sources":["../../../src/discrete/layers/boxes.ts"],"sourcesContent":["import type { NO_GROUPED} from '../../DataFrame';\nimport type {DataFrame,GroupKey} from '../../DataFrame';\nimport type {BoxLayer, DiscreteSettingsImpl} from '../DiscreteSettingsImpl';\nimport type {BoxesData} from './types';\nimport {getFacetStringKey} from '../utils/getFacetStringKey';\nimport {extent, max, min, quantileSorted} from 'd3-array';\nimport type {ColumnName, DataValue, Row} from '../../types';\nimport lodash from 'lodash';\n\nfunction getSortedConvertedValues (valuesRows: Row[], yGetter:(row:Row) => number, convertToScale:(v:number) => number, changeZeros = false) {\n    const valuesSorted = valuesRows.map(yGetter).sort((a, b) => a - b);\n    if (changeZeros) {\n        const firstMoreThanZero = lodash.find(valuesSorted, (v) => v > 0);\n        if (!firstMoreThanZero) {\n            throw Error('Group with all zeros in log scale');\n        }\n        return valuesSorted.map((v) => v === 0 ? firstMoreThanZero : v).map(convertToScale);\n    }\n    return valuesSorted.map(convertToScale);\n}\n\nexport class Box {\n    lower: number;\n    middle: number;\n    upper: number;\n    min: number;\n    max: number;\n    outliers: {\n        y: number;\n        id: string;\n        data: Row;\n    }[];\n\n    // Saved data for linking with visual properties (set color by grouping etc.)\n    primaryGrouping: GroupKey;\n    secondaryGrouping: GroupKey;\n    key: string;\n\n    // Bounds for correct chart viewport\n    boundsY: {\n        min: number;\n        max: number;\n    };\n\n    constructor(\n        valuesRows: Row[],\n        valueColumn: string,\n        keyColumn: string | null,\n        scale: 'linear' | 'log',\n        primaryGrouping: DataValue | typeof NO_GROUPED,\n        secondaryGrouping: DataValue | typeof NO_GROUPED,\n        lower: number,\n        middle: number,\n        upper: number,\n        k: number,\n        showOutliers = true\n    ) {\n        if (valuesRows.length === 0) {\n            throw Error('Unable to create box on empty data');\n        }\n        if (lower > middle || lower > upper || middle > upper) {\n            throw Error(`Invalid box bounds values: lower=${lower}, middle=${middle}, upper=${upper}`);\n        }\n        if (k < 0) {\n            throw Error(`Invalid box whiskers coefficient: k=${k}. It should be positive`);\n        }\n        const yGetter = (row: Row) => Number(row[valueColumn]);\n\n        this.primaryGrouping = String(primaryGrouping);\n        this.secondaryGrouping = String(secondaryGrouping);\n        this.key = `box_${this.primaryGrouping}_${this.secondaryGrouping}`;\n\n        //TODO: for speed use own quantile calculation; for comparison https://github.com/JetBrains/lets-plot/blob/ef4aecfa451b332e6e7544cfb3a2118c873f09c6/plot-base-portable/src/commonMain/kotlin/jetbrains/datalore/plot/base/stat/FiveNumberSummary.kt#L17\n        const convertToScale = (v: number) => (scale === 'log' ? Math.log10(v) : v);\n        const convertFromScale = (v: number) => (scale === 'log' ? Math.pow(10, v) : v);\n\n        // throw error for values <= 1\n        const valuesSortedConverted = getSortedConvertedValues(valuesRows, yGetter, convertToScale, scale === 'log');\n\n        const q1 = quantileSorted(valuesSortedConverted, lower) as number;\n        const q2 = quantileSorted(valuesSortedConverted, middle) as number;\n        const q3 = quantileSorted(valuesSortedConverted, upper) as number;\n        const interQuantileRange = q3 - q1;\n\n        this.upper = convertFromScale(q3);\n        this.middle = convertFromScale(q2);\n        this.lower = convertFromScale(q1);\n        // NB: Cut whiskers by min and max array values\n        this.min = Math.max(min(valuesRows, yGetter) as number, convertFromScale(q1 - k * interQuantileRange));\n        this.max = Math.min(max(valuesRows, yGetter) as number, convertFromScale(q3 + k * interQuantileRange));\n        this.outliers = valuesRows\n            .filter(row => yGetter(row) < this.min || yGetter(row) > this.max)\n            .map((row, idx) => ({\n                y: yGetter(row),\n                data: row,\n                id: keyColumn ? String(row[keyColumn]) : String(idx),\n            }));\n\n        const [minOutlier = Infinity, maxOutlier = -Infinity] = extent(this.outliers, item => item.y);\n        this.boundsY = {\n            min: showOutliers ? Math.min(this.min, minOutlier) : this.min,\n            max: showOutliers ? Math.max(this.max, maxOutlier) : this.max,\n        };\n    }\n}\n\nexport function getBoxesData(\n    layer: BoxLayer,\n    groupingKeys: {\n        facet: GroupKey[][],\n        primary: GroupKey[],\n        secondary: GroupKey[]\n    },\n    data: DataFrame,\n    y: ColumnName,\n    keyColumn: ColumnName | null,\n    yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']\n): BoxesData {\n    let minY = Infinity;\n    let maxY = -Infinity;\n\n    return {\n        type: 'box',\n        geoms: groupingKeys.facet.reduce((res: Record<string, Box[]>, facetKey) => {\n            const strFacetKey = getFacetStringKey(facetKey);\n            res[strFacetKey] = [];\n            groupingKeys.primary.forEach(primaryKey => {\n                groupingKeys.secondary.forEach(secondaryKey => {\n                    const rowValues = data.getRowsByGrouping([...facetKey, primaryKey, secondaryKey]);\n                    if (!rowValues.length) {\n                        return;\n                    }\n                    const box = new Box(\n                        rowValues,\n                        y.value,\n                        keyColumn?.value ?? null,\n                        yAxis.scale,\n                        primaryKey,\n                        secondaryKey,\n                        layer.stat.lower,\n                        layer.stat.medium,\n                        layer.stat.upper,\n                        layer.stat.k,\n                        layer.aes.showOutliers\n                    );\n                    if (box.boundsY.min < minY) {\n                        minY = box.boundsY.min;\n                    }\n                    if (box.boundsY.max > maxY) {\n                        maxY = box.boundsY.max;\n                    }\n                    res[strFacetKey].push(box);\n                });\n            });\n            return res;\n        }, {} as Record<GroupKey, Box[]>),\n        meta: {minY, maxY},\n        aes: layer.aes,\n    };\n}\n"],"names":["getSortedConvertedValues","valuesRows","yGetter","convertToScale","changeZeros","valuesSorted","a","b","firstMoreThanZero","lodash","v","Box","valueColumn","keyColumn","scale","primaryGrouping","secondaryGrouping","lower","middle","upper","k","showOutliers","__publicField","row","convertFromScale","valuesSortedConverted","q1","quantileSorted","q2","q3","interQuantileRange","min","max","idx","minOutlier","maxOutlier","extent","item","getBoxesData","layer","groupingKeys","data","y","yAxis","minY","maxY","res","facetKey","strFacetKey","getFacetStringKey","primaryKey","secondaryKey","rowValues","box"],"mappings":"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"}

package/dist/discrete/layers/dots.d.ts

@@ -0,0 +1,25 @@
+import { GroupKey, DataFrame } from '../../DataFrame';
+import { DiscreteSettingsImpl, DotLayer } from '../DiscreteSettingsImpl';
+import { DotsData } from './types';
+import { ColumnName, DataValue } from '../../types';
+export type DotsGroup = {
+    key: string;
+    values: {
+        y: number;
+        jitter: number;
+        id: string;
+        data: Record<string, DataValue>;
+    }[];
+    primaryGrouping: string;
+    secondaryGrouping: string;
+    boundsY: {
+        min: number;
+        max: number;
+    };
+};
+export declare function getDotsData(layer: DotLayer, groupingKeys: {
+    facet: GroupKey[][];
+    primary: GroupKey[];
+    secondary: GroupKey[];
+}, data: DataFrame, y: ColumnName, yAxis: DiscreteSettingsImpl['chartSettings']['yAxis'], keyColumn: ColumnName | null): DotsData;
+//# sourceMappingURL=dots.d.ts.map

package/dist/discrete/layers/dots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dots.d.ts","sourceRoot":"","sources":["../../../src/discrete/layers/dots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAC;AAGtC,OAAO,KAAK,EAAC,UAAU,EAAE,SAAS,EAAM,MAAM,aAAa,CAAC;AAI5D,MAAM,MAAM,SAAS,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;KAAC,EAAE,CAAC;IACnF,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;CACL,CAAC;AAEF,wBAAgB,WAAW,CACvB,KAAK,EAAE,QAAQ,EACf,YAAY,EAAE;IACV,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACxB,EACD,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,UAAU,EACb,KAAK,EAAE,oBAAoB,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,EACrD,SAAS,EAAE,UAAU,GAAG,IAAI,GAC7B,QAAQ,CAkDV"}

package/dist/discrete/layers/dots.js

@@ -0,0 +1,46 @@
+import { getOutliersBounds as I } from "../utils/getOutliersBounds.js";
+import { getFacetStringKey as y } from "../utils/getFacetStringKey.js";
+import F from "../../node_modules/d3-random/src/lcg.js";
+import Y from "../../node_modules/d3-array/src/extent.js";
+function O(g, i, v, x, b, l) {
+  let e = 1 / 0, r = -1 / 0;
+  const G = F(1);
+  return {
+    type: "dot",
+    geoms: i.facet.reduce((o, d) => {
+      const p = y(d);
+      return o[p] = [], i.primary.forEach((a) => {
+        i.secondary.forEach((s) => {
+          const u = v.getRowsByGrouping([...d, a, s]);
+          if (!u.length)
+            return;
+          const S = (t) => Number(t[x.value]);
+          let n = u.map((t, c) => ({
+            y: S(t),
+            jitter: G(),
+            id: String(l ? t[l.value] : c),
+            data: t
+          }));
+          if (!g.aes.showOutliers) {
+            const [t, c] = I(u, b.scale, S);
+            n = n.filter(({ y: h }) => h >= t && h <= c);
+          }
+          const [f = 1 / 0, m = -1 / 0] = Y(n, (t) => t.y);
+          f < e && (e = f), m > r && (r = m), o[p].push({
+            key: `dots_${String(a)}_${String(s)}`,
+            values: n,
+            primaryGrouping: String(a),
+            secondaryGrouping: String(s),
+            boundsY: { min: f, max: m }
+          });
+        });
+      }), o;
+    }, {}),
+    meta: { minY: e, maxY: r },
+    aes: g.aes
+  };
+}
+export {
+  O as getDotsData
+};
+//# sourceMappingURL=dots.js.map

package/dist/discrete/layers/dots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dots.js","sources":["../../../src/discrete/layers/dots.ts"],"sourcesContent":["import type {GroupKey} from '../../DataFrame';\nimport type {DataFrame} from '../../DataFrame';\nimport type {DiscreteSettingsImpl} from '../DiscreteSettingsImpl';\nimport type {DotLayer} from '../DiscreteSettingsImpl';\nimport type {DotsData} from './types';\nimport {getOutliersBounds} from '../utils';\nimport {getFacetStringKey} from '../utils/getFacetStringKey';\nimport type {ColumnName, DataValue, Row} from '../../types';\nimport {extent} from 'd3-array';\nimport {randomLcg} from 'd3-random';\n\nexport type DotsGroup = {\n    key: string;\n    values: {y: number; jitter: number; id: string; data: Record<string, DataValue>}[];\n    primaryGrouping: string;\n    secondaryGrouping: string;\n    boundsY: {\n        min: number;\n        max: number;\n    };\n};\n\nexport function getDotsData(\n    layer: DotLayer,\n    groupingKeys: {\n        facet: GroupKey[][],\n        primary: GroupKey[],\n        secondary: GroupKey[]\n    },\n    data: DataFrame,\n    y: ColumnName,\n    yAxis: DiscreteSettingsImpl['chartSettings']['yAxis'],\n    keyColumn: ColumnName | null\n): DotsData {\n    let minY = Infinity;\n    let maxY = -Infinity;\n    const getJitter = randomLcg(1);\n\n    return {\n        type: 'dot',\n        geoms: groupingKeys.facet.reduce((res: Record<string, DotsGroup[]>, facetKey) => {\n            const strFacetKey = getFacetStringKey(facetKey);\n            res[strFacetKey] = [];\n            groupingKeys.primary.forEach(primaryKey => {\n                groupingKeys.secondary.forEach(secondaryKey => {\n                    const values = data.getRowsByGrouping([...facetKey, primaryKey, secondaryKey]);\n                    if (!values.length) {\n                        return;\n                    }\n                    const yGetter = (row: Row) => Number(row[y.value]);\n                    let valuesFiltered = values.map((row, idx) => ({\n                        y: yGetter(row),\n                        jitter: getJitter(),\n                        id: keyColumn ? String(row[keyColumn.value]) : String(idx),\n                        data: row,\n                    }));\n                    if (!layer.aes.showOutliers) {\n                        const [boundsMin, boundMax] = getOutliersBounds(values, yAxis.scale, yGetter);\n                        valuesFiltered = valuesFiltered.filter(({ y }) => {\n                            return y >= boundsMin && y <= boundMax;\n                        });\n                    }\n                    const [min = Infinity, max = -Infinity] = extent(valuesFiltered, (v) => v.y);\n                    if (min < minY) {\n                        minY = min;\n                    }\n                    if (max > maxY) {\n                        maxY = max;\n                    }\n                    res[strFacetKey].push({\n                        key: `dots_${String(primaryKey)}_${String(secondaryKey)}`,\n                        values: valuesFiltered,\n                        primaryGrouping: String(primaryKey),\n                        secondaryGrouping: String(secondaryKey),\n                        boundsY: {min, max},\n                    });\n                });\n            });\n            return res;\n        }, {}),\n        meta: {minY, maxY},\n        aes: layer.aes,\n    };\n}\n"],"names":["getDotsData","layer","groupingKeys","data","y","yAxis","keyColumn","minY","maxY","getJitter","randomLcg","res","facetKey","strFacetKey","getFacetStringKey","primaryKey","secondaryKey","values","yGetter","row","valuesFiltered","idx","boundsMin","boundMax","getOutliersBounds","min","max","extent","v"],"mappings":";;;;AAsBO,SAASA,EACZC,GACAC,GAKAC,GACAC,GACAC,GACAC,GACQ;AACR,MAAIC,IAAO,OACPC,IAAO;AACX,QAAMC,IAAYC,EAAU,CAAC;AAE7B,SAAO;AAAA,IACH,MAAM;AAAA,IACN,OAAOR,EAAa,MAAM,OAAO,CAACS,GAAkCC,MAAa;AAC7E,YAAMC,IAAcC,EAAkBF,CAAQ;AAC9C,aAAAD,EAAIE,CAAW,IAAI,CAAA,GACnBX,EAAa,QAAQ,QAAQ,CAAAa,MAAc;AACvC,QAAAb,EAAa,UAAU,QAAQ,CAAAc,MAAgB;AAC3C,gBAAMC,IAASd,EAAK,kBAAkB,CAAC,GAAGS,GAAUG,GAAYC,CAAY,CAAC;AAC7E,cAAI,CAACC,EAAO;AACR;AAEJ,gBAAMC,IAAU,CAACC,MAAa,OAAOA,EAAIf,EAAE,KAAK,CAAC;AACjD,cAAIgB,IAAiBH,EAAO,IAAI,CAACE,GAAKE,OAAS;AAAA,YAC3C,GAAGH,EAAQC,CAAG;AAAA,YACd,QAAQV,EAAA;AAAA,YACR,IAAgB,OAAZH,IAAmBa,EAAIb,EAAU,KAAK,IAAYe,CAAX;AAAA,YAC3C,MAAMF;AAAA,UAAA,EACR;AACF,cAAI,CAAClB,EAAM,IAAI,cAAc;AACzB,kBAAM,CAACqB,GAAWC,CAAQ,IAAIC,EAAkBP,GAAQZ,EAAM,OAAOa,CAAO;AAC5E,YAAAE,IAAiBA,EAAe,OAAO,CAAC,EAAE,GAAAhB,QAC/BA,KAAKkB,KAAalB,KAAKmB,CACjC;AAAA,UACL;AACA,gBAAM,CAACE,IAAM,OAAUC,IAAM,MAAS,IAAIC,EAAOP,GAAgB,CAACQ,MAAMA,EAAE,CAAC;AAC3E,UAAIH,IAAMlB,MACNA,IAAOkB,IAEPC,IAAMlB,MACNA,IAAOkB,IAEXf,EAAIE,CAAW,EAAE,KAAK;AAAA,YAClB,KAAK,QAAQ,OAAOE,CAAU,CAAC,IAAI,OAAOC,CAAY,CAAC;AAAA,YACvD,QAAQI;AAAA,YACR,iBAAiB,OAAOL,CAAU;AAAA,YAClC,mBAAmB,OAAOC,CAAY;AAAA,YACtC,SAAS,EAAC,KAAAS,GAAK,KAAAC,EAAA;AAAA,UAAG,CACrB;AAAA,QACL,CAAC;AAAA,MACL,CAAC,GACMf;AAAA,IACX,GAAG,CAAA,CAAE;AAAA,IACL,MAAM,EAAC,MAAAJ,GAAM,MAAAC,EAAA;AAAA,IACb,KAAKP,EAAM;AAAA,EAAA;AAEnB;"}

package/dist/discrete/layers/errorbars.d.ts

@@ -0,0 +1,21 @@
+import { GroupKey, DataFrame } from '../../DataFrame';
+import { ErrorBarLayer, DiscreteSettingsImpl } from '../DiscreteSettingsImpl';
+import { ErrorBarsData } from './types';
+export interface ErrorBar {
+    min: number;
+    max: number;
+    value: number;
+    key: string;
+    primaryGrouping: string;
+    secondaryGrouping: string;
+    boundsY: {
+        min: number;
+        max: number;
+    };
+}
+export declare function getErrorBarsData(layer: ErrorBarLayer, groupingKeys: {
+    facet: GroupKey[][];
+    primary: GroupKey[];
+    secondary: GroupKey[];
+}, data: DataFrame, y: DiscreteSettingsImpl['y'], yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']): ErrorBarsData;
+//# sourceMappingURL=errorbars.d.ts.map

package/dist/discrete/layers/errorbars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorbars.d.ts","sourceRoot":"","sources":["../../../src/discrete/layers/errorbars.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,SAAS,CAAC;AAM3C,MAAM,WAAW,QAAQ;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;CACL;AAsCD,wBAAgB,gBAAgB,CAC5B,KAAK,EAAE,aAAa,EACpB,YAAY,EAAE;IACV,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACxB,EACD,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,EAC5B,KAAK,EAAE,oBAAoB,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,GACtD,aAAa,CA8Cf"}

package/dist/discrete/layers/errorbars.js

@@ -0,0 +1,67 @@
+import { getFacetStringKey as b } from "../utils/getFacetStringKey.js";
+import { exhaustive as w } from "../../utils/index.js";
+import k from "../../node_modules/d3-array/src/quantile.js";
+import m from "../../node_modules/d3-array/src/mean.js";
+function q(t) {
+  const n = m(t);
+  return m(t.map((a) => Math.pow(a - n, 2)));
+}
+function s(t) {
+  return Math.sqrt(q(t));
+}
+function x(t) {
+  return s(t) / Math.sqrt(t.length);
+}
+function D(t) {
+  return 1.96 * s(t);
+}
+function F(t, n) {
+  if (n === "median")
+    return k(t, 0.5);
+  if (n === "mean")
+    return m(t);
+  w(n, "Unknown points calculation");
+}
+function G(t, n) {
+  if (n === "sd")
+    return s(t);
+  if (n === "se")
+    return x(t);
+  if (n === "ci")
+    return D(t);
+  w(n, "Unknown error interval calculation");
+}
+function U(t, n, a, E, g) {
+  let i = 1 / 0, c = -1 / 0;
+  return {
+    type: "errorbar",
+    geoms: n.facet.reduce((u, p) => {
+      const h = b(p);
+      u[h] = [];
+      const I = (r) => g.scale === "log" ? Math.log10(r) : r, d = (r) => g.scale === "log" ? Math.pow(10, r) : r;
+      return n.primary.forEach((r) => {
+        n.secondary.forEach((f) => {
+          const S = a.getColumnByGrouping([...p, r, f], E.value);
+          if (!S.length)
+            return;
+          const M = S.map(I), l = d(F(M, t.pointsValues)), v = d(G(M, t.interval)), o = l - v, e = l + v;
+          o < i && (i = o), e > c && (c = e), u[h].push({
+            key: `errorbar_${String(r)}_${String(f)}`,
+            primaryGrouping: String(r),
+            secondaryGrouping: String(f),
+            value: l,
+            min: o,
+            max: e,
+            boundsY: { min: o, max: e }
+          });
+        });
+      }), u;
+    }, {}),
+    meta: { minY: i, maxY: c },
+    aes: t.aes
+  };
+}
+export {
+  U as getErrorBarsData
+};
+//# sourceMappingURL=errorbars.js.map

package/dist/discrete/layers/errorbars.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorbars.js","sources":["../../../src/discrete/layers/errorbars.ts"],"sourcesContent":["import type {GroupKey} from '../../DataFrame';\nimport type {DataFrame} from '../../DataFrame';\nimport type {ErrorBarLayer} from '../DiscreteSettingsImpl';\nimport type {DiscreteSettingsImpl} from '../DiscreteSettingsImpl';\nimport type {ErrorBarsData} from './types';\nimport {getFacetStringKey} from '../utils/getFacetStringKey';\nimport type {SummaryErrorValue, SummaryGroupValue} from '../../types';\nimport {exhaustive} from '../../utils';\nimport {mean, quantile} from 'd3-array';\n\nexport interface ErrorBar {\n    min: number;\n    max: number;\n    value: number;\n    key: string;\n    primaryGrouping: string;\n    secondaryGrouping: string;\n    boundsY: {\n        min: number;\n        max: number;\n    };\n}\n\nfunction getVariance(arr: number[]) {\n    const vMean = mean(arr) as number;\n    return mean(arr.map(v => Math.pow(v - vMean, 2))) as number;\n}\nfunction getStandardDeviation(arr: number[]) {\n    return Math.sqrt(getVariance(arr));\n}\nfunction getStandardError(arr: number[]) {\n    return getStandardDeviation(arr) / Math.sqrt(arr.length);\n}\nfunction getConfidentInterval95(arr: number[]) {\n    return 1.96 * getStandardDeviation(arr);\n}\n\nfunction calculateDot(values: number[], value: SummaryGroupValue): number {\n    if (value === 'median') {\n        return quantile(values, 0.5) as number;\n    }\n    if (value === 'mean') {\n        return mean(values) as number;\n    }\n    exhaustive(value, 'Unknown points calculation');\n}\nfunction calculateInterval(values: number[], interval: SummaryErrorValue): number {\n    if (interval === 'sd') {\n        return getStandardDeviation(values);\n    }\n    if (interval === 'se') {\n        return getStandardError(values);\n    }\n    if (interval === 'ci') {\n        return getConfidentInterval95(values);\n    }\n    exhaustive(interval, 'Unknown error interval calculation');\n}\n\nexport function getErrorBarsData(\n    layer: ErrorBarLayer,\n    groupingKeys: {\n        facet: GroupKey[][],\n        primary: GroupKey[],\n        secondary: GroupKey[]\n    },\n    data: DataFrame,\n    y: DiscreteSettingsImpl['y'],\n    yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']\n): ErrorBarsData {\n    let minY = Infinity;\n    let maxY = -Infinity;\n\n    return {\n        type: 'errorbar',\n        geoms: groupingKeys.facet.reduce((res: Record<string, ErrorBar[]>, facetKey) => {\n            const strFacetKey = getFacetStringKey(facetKey);\n            res[strFacetKey] = [];\n            const convertToScale = (v: number) => (yAxis.scale === 'log' ? Math.log10(v) : v);\n            const convertFromScale = (v: number) => (yAxis.scale === 'log' ? Math.pow(10, v) : v);\n\n            groupingKeys.primary.forEach(primaryKey => {\n                groupingKeys.secondary.forEach(secondaryKey => {\n                    const values = data.getColumnByGrouping([...facetKey, primaryKey, secondaryKey], y.value);\n                    if (!values.length) {\n                        return;\n                    }\n                    const convertedValues = values.map(convertToScale);\n                    const value = convertFromScale(calculateDot(convertedValues, layer.pointsValues));\n                    const interval = convertFromScale(calculateInterval(convertedValues, layer.interval));\n                    const min = value - interval;\n                    const max = value + interval;\n\n                    if (min < minY) {\n                        minY = min;\n                    }\n                    if (max > maxY) {\n                        maxY = max;\n                    }\n                    res[strFacetKey].push({\n                        key: `errorbar_${String(primaryKey)}_${String(secondaryKey)}`,\n                        primaryGrouping: String(primaryKey),\n                        secondaryGrouping: String(secondaryKey),\n                        value,\n                        min,\n                        max,\n                        boundsY: {min, max},\n                    });\n                });\n            });\n            return res;\n        }, {}),\n        meta: {minY, maxY},\n        aes: layer.aes\n    };\n}\n"],"names":["getVariance","arr","vMean","mean","v","getStandardDeviation","getStandardError","getConfidentInterval95","calculateDot","values","value","quantile","exhaustive","calculateInterval","interval","getErrorBarsData","layer","groupingKeys","data","y","yAxis","minY","maxY","res","facetKey","strFacetKey","getFacetStringKey","convertToScale","convertFromScale","primaryKey","secondaryKey","convertedValues","min","max"],"mappings":";;;;AAuBA,SAASA,EAAYC,GAAe;AAChC,QAAMC,IAAQC,EAAKF,CAAG;AACtB,SAAOE,EAAKF,EAAI,IAAI,CAAAG,MAAK,KAAK,IAAIA,IAAIF,GAAO,CAAC,CAAC,CAAC;AACpD;AACA,SAASG,EAAqBJ,GAAe;AACzC,SAAO,KAAK,KAAKD,EAAYC,CAAG,CAAC;AACrC;AACA,SAASK,EAAiBL,GAAe;AACrC,SAAOI,EAAqBJ,CAAG,IAAI,KAAK,KAAKA,EAAI,MAAM;AAC3D;AACA,SAASM,EAAuBN,GAAe;AAC3C,SAAO,OAAOI,EAAqBJ,CAAG;AAC1C;AAEA,SAASO,EAAaC,GAAkBC,GAAkC;AACtE,MAAIA,MAAU;AACV,WAAOC,EAASF,GAAQ,GAAG;AAE/B,MAAIC,MAAU;AACV,WAAOP,EAAKM,CAAM;AAEtB,EAAAG,EAAWF,GAAO,4BAA4B;AAClD;AACA,SAASG,EAAkBJ,GAAkBK,GAAqC;AAC9E,MAAIA,MAAa;AACb,WAAOT,EAAqBI,CAAM;AAEtC,MAAIK,MAAa;AACb,WAAOR,EAAiBG,CAAM;AAElC,MAAIK,MAAa;AACb,WAAOP,EAAuBE,CAAM;AAExC,EAAAG,EAAWE,GAAU,oCAAoC;AAC7D;AAEO,SAASC,EACZC,GACAC,GAKAC,GACAC,GACAC,GACa;AACb,MAAIC,IAAO,OACPC,IAAO;AAEX,SAAO;AAAA,IACH,MAAM;AAAA,IACN,OAAOL,EAAa,MAAM,OAAO,CAACM,GAAiCC,MAAa;AAC5E,YAAMC,IAAcC,EAAkBF,CAAQ;AAC9C,MAAAD,EAAIE,CAAW,IAAI,CAAA;AACnB,YAAME,IAAiB,CAACvB,MAAegB,EAAM,UAAU,QAAQ,KAAK,MAAMhB,CAAC,IAAIA,GACzEwB,IAAmB,CAACxB,MAAegB,EAAM,UAAU,QAAQ,KAAK,IAAI,IAAIhB,CAAC,IAAIA;AAEnF,aAAAa,EAAa,QAAQ,QAAQ,CAAAY,MAAc;AACvC,QAAAZ,EAAa,UAAU,QAAQ,CAAAa,MAAgB;AAC3C,gBAAMrB,IAASS,EAAK,oBAAoB,CAAC,GAAGM,GAAUK,GAAYC,CAAY,GAAGX,EAAE,KAAK;AACxF,cAAI,CAACV,EAAO;AACR;AAEJ,gBAAMsB,IAAkBtB,EAAO,IAAIkB,CAAc,GAC3CjB,IAAQkB,EAAiBpB,EAAauB,GAAiBf,EAAM,YAAY,CAAC,GAC1EF,IAAWc,EAAiBf,EAAkBkB,GAAiBf,EAAM,QAAQ,CAAC,GAC9EgB,IAAMtB,IAAQI,GACdmB,IAAMvB,IAAQI;AAEpB,UAAIkB,IAAMX,MACNA,IAAOW,IAEPC,IAAMX,MACNA,IAAOW,IAEXV,EAAIE,CAAW,EAAE,KAAK;AAAA,YAClB,KAAK,YAAY,OAAOI,CAAU,CAAC,IAAI,OAAOC,CAAY,CAAC;AAAA,YAC3D,iBAAiB,OAAOD,CAAU;AAAA,YAClC,mBAAmB,OAAOC,CAAY;AAAA,YACtC,OAAApB;AAAA,YACA,KAAAsB;AAAA,YACA,KAAAC;AAAA,YACA,SAAS,EAAC,KAAAD,GAAK,KAAAC,EAAA;AAAA,UAAG,CACrB;AAAA,QACL,CAAC;AAAA,MACL,CAAC,GACMV;AAAA,IACX,GAAG,CAAA,CAAE;AAAA,IACL,MAAM,EAAC,MAAAF,GAAM,MAAAC,EAAA;AAAA,IACb,KAAKN,EAAM;AAAA,EAAA;AAEnB;"}

package/dist/discrete/layers/index.d.ts

@@ -0,0 +1,13 @@
+export * from './boxes';
+export * from './violins';
+export * from './sina';
+export * from './dots';
+export * from './lines';
+export * from './errorbars';
+export * from './bar';
+export * from './stackedBar';
+export * from './binnedDots';
+export * from './pairedPoints';
+export * from './logo';
+export * from './stats';
+//# sourceMappingURL=index.d.ts.map

package/dist/discrete/layers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/discrete/layers/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/discrete/layers/lines.d.ts

@@ -0,0 +1,17 @@
+import { GroupKey, DataFrame } from '../../DataFrame';
+import { DiscreteSettingsImpl, LineLayer } from '../DiscreteSettingsImpl';
+import { LinesData } from './types';
+export interface Line {
+    dots: Record<string, number>;
+    boundsY: {
+        min: number;
+        max: number;
+    };
+    key: string;
+}
+export declare function getLinesData(layer: LineLayer, groupingKeys: {
+    facet: GroupKey[][];
+    primary: GroupKey[];
+    secondary: GroupKey[];
+}, data: DataFrame, y: DiscreteSettingsImpl['y'], yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']): LinesData;
+//# sourceMappingURL=lines.d.ts.map

package/dist/discrete/layers/lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.d.ts","sourceRoot":"","sources":["../../../src/discrete/layers/lines.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,oBAAoB,EAAE,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAC;AAMvC,MAAM,WAAW,IAAI;IACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,EAAE;QACL,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf,CAAC;IACF,GAAG,EAAE,MAAM,CAAC;CACf;AAYD,wBAAgB,YAAY,CACxB,KAAK,EAAE,SAAS,EAChB,YAAY,EAAE;IACV,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,SAAS,EAAE,QAAQ,EAAE,CAAA;CACxB,EACD,IAAI,EAAE,SAAS,EACf,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,EAC5B,KAAK,EAAE,oBAAoB,CAAC,eAAe,CAAC,CAAC,OAAO,CAAC,GACtD,SAAS,CAoEX"}

package/dist/discrete/layers/lines.js

@@ -0,0 +1,55 @@
+import { getOutliersBounds as w } from "../utils/getOutliersBounds.js";
+import { getFacetStringKey as F } from "../utils/getFacetStringKey.js";
+import { exhaustive as M } from "../../utils/index.js";
+import v from "../../node_modules/d3-array/src/quantile.js";
+import B from "../../node_modules/d3-array/src/mean.js";
+function O(i, n) {
+  if (n === "median")
+    return v(i, 0.5);
+  if (n === "mean")
+    return B(i);
+  M(n, `Unknown line points calculation for dot layer: ${n}`);
+}
+function $(i, n, d, g, r) {
+  let l = 1 / 0, a = -1 / 0;
+  return {
+    type: "line",
+    geoms: n.facet.reduce((u, f) => {
+      const h = F(f);
+      u[h] = [];
+      let p = -1 / 0, b = 1 / 0;
+      return i.aes.showOutliers || ([p, b] = w(d.getColumnByGrouping([...f], g.value), r.scale)), n.secondary.forEach((Y) => {
+        const o = {
+          key: `${String(Y)}`,
+          boundsY: {
+            min: 1 / 0,
+            max: -1 / 0
+          },
+          dots: {}
+        };
+        let m = !1;
+        const x = (e) => r.scale === "log" ? Math.log10(e) : e, S = (e) => r.scale === "log" ? Math.pow(10, e) : e;
+        n.primary.forEach((e) => {
+          const s = d.getColumnByGrouping([...f, e, Y], g.value);
+          if (!s.length) {
+            m = !0;
+            return;
+          }
+          let c = s;
+          if (i.aes.showOutliers || (c = s.filter((I) => I >= p && I <= b)), !c.length) {
+            m = !0;
+            return;
+          }
+          const t = S(O(c.map(x), i.pointsValues));
+          o.dots[String(e)] = t, t < l && (l = t), t > a && (a = t), t < o.boundsY.min && (o.boundsY.min = t), t > o.boundsY.max && (o.boundsY.max = t);
+        }), m || u[h].push(o);
+      }), u;
+    }, {}),
+    meta: { minY: l, maxY: a },
+    aes: i.aes
+  };
+}
+export {
+  $ as getLinesData
+};
+//# sourceMappingURL=lines.js.map

package/dist/discrete/layers/lines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lines.js","sources":["../../../src/discrete/layers/lines.ts"],"sourcesContent":["import type {GroupKey} from '../../DataFrame';\nimport type {DataFrame} from '../../DataFrame';\nimport type {DiscreteSettingsImpl, LineLayer} from '../DiscreteSettingsImpl';\nimport type {LinesData} from './types';\nimport {getOutliersBounds} from '../utils';\nimport {getFacetStringKey} from '../utils/getFacetStringKey';\nimport {exhaustive} from '../../utils';\nimport {mean, quantile} from 'd3-array';\n\nexport interface Line {\n    dots: Record<string, number>;\n    boundsY: {\n        min: number;\n        max: number;\n    };\n    key: string;\n}\n\nfunction calculateDot(values: number[], pointsValues: LineLayer['pointsValues']): number {\n    if (pointsValues === 'median') {\n        return quantile(values, 0.5) as number;\n    }\n    if (pointsValues === 'mean') {\n        return mean(values) as number;\n    }\n    exhaustive(pointsValues, `Unknown line points calculation for dot layer: ${pointsValues}`);\n}\n\nexport function getLinesData(\n    layer: LineLayer,\n    groupingKeys: {\n        facet: GroupKey[][],\n        primary: GroupKey[],\n        secondary: GroupKey[]\n    },\n    data: DataFrame,\n    y: DiscreteSettingsImpl['y'],\n    yAxis: DiscreteSettingsImpl['chartSettings']['yAxis']\n): LinesData {\n    let minY = Infinity;\n    let maxY = -Infinity;\n\n    return {\n        type: 'line',\n        geoms: groupingKeys.facet.reduce((res: Record<string, Line[]>, facetKey) => {\n            const strFacetKey = getFacetStringKey(facetKey);\n            res[strFacetKey] = [];\n            let boundMin = -Infinity;\n            let boundMax = Infinity;\n            if (!layer.aes.showOutliers) {\n                [boundMin, boundMax] = getOutliersBounds(data.getColumnByGrouping([...facetKey], y.value), yAxis.scale);\n            }\n\n            groupingKeys.secondary.forEach(secondaryKey => {\n                const line: Line = {\n                    key: `${String(secondaryKey)}`,\n                    boundsY: {\n                        min: Infinity,\n                        max: -Infinity,\n                    },\n                    dots: {},\n                };\n                // if point data by primary/secondary key missed in source data or filtered as outliers, remove whole line\n                let missedPoint = false;\n                const convertToScale = (v: number) => (yAxis.scale === 'log' ? Math.log10(v) : v);\n                const convertFromScale = (v: number) => (yAxis.scale === 'log' ? Math.pow(10, v) : v);\n\n                groupingKeys.primary.forEach(primaryKey => {\n                    const values = data.getColumnByGrouping([...facetKey, primaryKey, secondaryKey], y.value);\n                    if (!values.length) {\n                        missedPoint = true;\n                        return;\n                    }\n                    let valuesFiltered = values;\n                    if (!layer.aes.showOutliers) {\n                        valuesFiltered = values.filter((v) => v >= boundMin && v <= boundMax);\n                    }\n                    if (!valuesFiltered.length) {\n                        missedPoint = true;\n                        return;\n                    }\n\n                    const dot = convertFromScale(calculateDot(valuesFiltered.map(convertToScale), layer.pointsValues));\n                    line.dots[String(primaryKey)] = dot;\n                    if (dot < minY) {\n                        minY = dot;\n                    }\n                    if (dot > maxY) {\n                        maxY = dot;\n                    }\n                    if (dot < line.boundsY.min) {\n                        line.boundsY.min = dot;\n                    }\n                    if (dot > line.boundsY.max) {\n                        line.boundsY.max = dot;\n                    }\n                });\n                if (!missedPoint) {\n                    res[strFacetKey].push(line);\n                }\n            });\n            return res;\n        }, {}),\n        meta: {minY, maxY},\n        aes: layer.aes\n    };\n}\n"],"names":["calculateDot","values","pointsValues","quantile","mean","exhaustive","getLinesData","layer","groupingKeys","data","y","yAxis","minY","maxY","res","facetKey","strFacetKey","getFacetStringKey","boundMin","boundMax","getOutliersBounds","secondaryKey","line","missedPoint","convertToScale","v","convertFromScale","primaryKey","valuesFiltered","dot"],"mappings":";;;;;AAkBA,SAASA,EAAaC,GAAkBC,GAAiD;AACrF,MAAIA,MAAiB;AACjB,WAAOC,EAASF,GAAQ,GAAG;AAE/B,MAAIC,MAAiB;AACjB,WAAOE,EAAKH,CAAM;AAEtB,EAAAI,EAAWH,GAAc,kDAAkDA,CAAY,EAAE;AAC7F;AAEO,SAASI,EACZC,GACAC,GAKAC,GACAC,GACAC,GACS;AACT,MAAIC,IAAO,OACPC,IAAO;AAEX,SAAO;AAAA,IACH,MAAM;AAAA,IACN,OAAOL,EAAa,MAAM,OAAO,CAACM,GAA6BC,MAAa;AACxE,YAAMC,IAAcC,EAAkBF,CAAQ;AAC9C,MAAAD,EAAIE,CAAW,IAAI,CAAA;AACnB,UAAIE,IAAW,QACXC,IAAW;AACf,aAAKZ,EAAM,IAAI,iBACX,CAACW,GAAUC,CAAQ,IAAIC,EAAkBX,EAAK,oBAAoB,CAAC,GAAGM,CAAQ,GAAGL,EAAE,KAAK,GAAGC,EAAM,KAAK,IAG1GH,EAAa,UAAU,QAAQ,CAAAa,MAAgB;AAC3C,cAAMC,IAAa;AAAA,UACf,KAAK,GAAG,OAAOD,CAAY,CAAC;AAAA,UAC5B,SAAS;AAAA,YACL,KAAK;AAAA,YACL,KAAK;AAAA,UAAA;AAAA,UAET,MAAM,CAAA;AAAA,QAAC;AAGX,YAAIE,IAAc;AAClB,cAAMC,IAAiB,CAACC,MAAed,EAAM,UAAU,QAAQ,KAAK,MAAMc,CAAC,IAAIA,GACzEC,IAAmB,CAACD,MAAed,EAAM,UAAU,QAAQ,KAAK,IAAI,IAAIc,CAAC,IAAIA;AAEnF,QAAAjB,EAAa,QAAQ,QAAQ,CAAAmB,MAAc;AACvC,gBAAM1B,IAASQ,EAAK,oBAAoB,CAAC,GAAGM,GAAUY,GAAYN,CAAY,GAAGX,EAAE,KAAK;AACxF,cAAI,CAACT,EAAO,QAAQ;AAChB,YAAAsB,IAAc;AACd;AAAA,UACJ;AACA,cAAIK,IAAiB3B;AAIrB,cAHKM,EAAM,IAAI,iBACXqB,IAAiB3B,EAAO,OAAO,CAACwB,MAAMA,KAAKP,KAAYO,KAAKN,CAAQ,IAEpE,CAACS,EAAe,QAAQ;AACxB,YAAAL,IAAc;AACd;AAAA,UACJ;AAEA,gBAAMM,IAAMH,EAAiB1B,EAAa4B,EAAe,IAAIJ,CAAc,GAAGjB,EAAM,YAAY,CAAC;AACjG,UAAAe,EAAK,KAAK,OAAOK,CAAU,CAAC,IAAIE,GAC5BA,IAAMjB,MACNA,IAAOiB,IAEPA,IAAMhB,MACNA,IAAOgB,IAEPA,IAAMP,EAAK,QAAQ,QACnBA,EAAK,QAAQ,MAAMO,IAEnBA,IAAMP,EAAK,QAAQ,QACnBA,EAAK,QAAQ,MAAMO;AAAA,QAE3B,CAAC,GACIN,KACDT,EAAIE,CAAW,EAAE,KAAKM,CAAI;AAAA,MAElC,CAAC,GACMR;AAAA,IACX,GAAG,CAAA,CAAE;AAAA,IACL,MAAM,EAAC,MAAAF,GAAM,MAAAC,EAAA;AAAA,IACb,KAAKN,EAAM;AAAA,EAAA;AAEnB;"}