@milaboratories/miplots4 1.0.129 → 1.0.131

package/dist/types/scatterplot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scatterplot.d.ts","sourceRoot":"","sources":["../../src/types/scatterplot.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scatterplot.d.ts","sourceRoot":"","sources":["../../src/types/scatterplot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,oCAAoC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACnG,OAAO,EAGH,mCAAmC,EAMtC,MAAM,UAAU,CAAC;AAElB,KAAK,gBAAgB,CAAC,SAAS,SAAS,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,OAAO,oCAAoC,CAAC,SAAS,CAAC,CAAC,CAAC;AACxH,KAAK,iBAAiB,CAAC,SAAS,SAAS,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,OAAO,mCAAmC,CAAC,SAAS,CAAC,CAAC,CAAC;AAExH,MAAM,MAAM,wBAAwB,CAAC,SAAS,IAAI,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAClG,MAAM,MAAM,uBAAuB,CAAC,SAAS,IAAI,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAElG,QAAA,MAAM,gBAAgB;;;;;;;;;;;;EAIpB,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAErE,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASnB,CAAC;AACH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpB,CAAC;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA+C,CAAC;AAE5E,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,CACtC,MAAM,EACN;IACI,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,OAAO,EAAE,CAAC,MAAM,OAAO,CAAC,EAAE,CAAC;IAC3B,MAAM,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,OAAO,KAAK,SAAS,GAAG,SAAS,CAAC;IACzE,MAAM,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;CACpC,CACJ,CAAC"}

package/dist/types/scatterplot.js

@@ -1,5 +1,5 @@
-import { continuousAesMappingFromValueSchema as n, PointShapeSchema as i, LineShapeSchema as l, ColumnNameSchema as t, AesMapSchema as p, AxisSettingsSchema as a, FrameTypeSchema as r, LegendPositionSchema as s, TitlePositionSchema as c } from "./common.js";
 import o from "../node_modules/zod/lib/index.js";
+import { continuousAesMappingFromValueSchema as n, PointShapeSchema as i, LineShapeSchema as l, ColumnNameSchema as t, AesRecordSchema as p, AxisSettingsSchema as a, FrameTypeSchema as r, LegendPositionSchema as s, TitlePositionSchema as c } from "./common.js";
 const e = o.object({
   type: o.literal("grouping"),
   value: o.string(),

package/dist/types/scatterplot.js.map

@@ -1 +1 @@
-{"version":3,"file":"scatterplot.js","sources":["../../src/types/scatterplot.ts"],"sourcesContent":["import type {AesItem, AesMap, categoricalAesMappingFromValueSchema} from './common';\nimport {AesMapSchema} from './common';\nimport {\n    AxisSettingsSchema,\n    ColumnNameSchema,\n    continuousAesMappingFromValueSchema,\n    FrameTypeSchema,\n    LegendPositionSchema,\n    LineShapeSchema,\n    PointShapeSchema,\n    TitlePositionSchema,\n} from './common';\nimport {z} from 'zod';\n\ntype catAesFromColumn<ValueType extends z.ZodType> = ReturnType<typeof categoricalAesMappingFromValueSchema<ValueType>>;\ntype contAesFromColumn<ValueType extends z.ZodType> = ReturnType<typeof continuousAesMappingFromValueSchema<ValueType>>;\n\nexport type CategoricalAesFromColumn<ValueType> = z.infer<catAesFromColumn<z.ZodType<ValueType>>>;\nexport type ContinuousAesFromColumn<ValueType> = z.infer<contAesFromColumn<z.ZodType<ValueType>>>;\n\nconst InheritAesSchema = z.object({\n    type: z.literal('grouping'),\n    value: z.string(), // link to aes mapped to column\n    palette: z.optional(z.array(z.string())) // if defined we use palette to create mapping without inheritedAes field\n});\nexport type InheritAesScatterplot = z.infer<typeof InheritAesSchema>;\n\nconst DotsLayerSchema = z.object({\n    type: z.literal('dots'),\n    aes: z.optional(\n        z.object({\n            dotFill: z.optional(z.union([z.string(), InheritAesSchema, continuousAesMappingFromValueSchema(z.string())])),\n            dotShape: z.optional(z.union([PointShapeSchema, InheritAesSchema])),\n            dotSize: z.optional(z.union([z.number(), continuousAesMappingFromValueSchema(z.number())])),\n        })\n    ),\n});\nconst CurveLayerSchema = z.object({\n    type: z.literal('curve'),\n    smoothing: z.optional(z.boolean()),\n    aes: z.optional(\n        z.object({\n            lineWidth: z.optional(z.number()),\n            lineShape: z.optional(LineShapeSchema),\n            lineColor: z.optional(z.union([z.string(), InheritAesSchema, continuousAesMappingFromValueSchema(z.string())])),\n            opacity: z.optional(z.number()),\n        })\n    ),\n});\nconst ScatterplotLayerSchema = z.union([DotsLayerSchema, CurveLayerSchema]);\n\nexport type DotsLayer = z.infer<typeof DotsLayerSchema>;\nexport type CurveLayer = z.infer<typeof CurveLayerSchema>;\nexport type ScatterplotLayer = z.infer<typeof ScatterplotLayerSchema>;\n\nexport const ScatterplotSettingsSchema = z.object({\n    type: z.literal('scatterplot'),\n    title: z.object({\n        name: z.string(),\n        show: z.optional(z.boolean()),\n        position: z.optional(TitlePositionSchema),\n    }),\n    size: z.optional(\n        z.object({\n            width: z.optional(z.number()),\n            height: z.optional(z.number()),\n        })\n    ),\n    legend: z.optional(\n        z.object({\n            show: z.optional(z.boolean()),\n            position: z.optional(LegendPositionSchema),\n        })\n    ),\n    tooltips: z.optional(\n        z.object({\n            show: z.optional(z.boolean()),\n            content: z.optional(z.array(ColumnNameSchema)),\n        })\n    ),\n    frame: z.optional(z.object({type: z.optional(FrameTypeSchema)})),\n    facetSettings: z.optional(\n        z.object({\n            sharedX: z.optional(z.boolean()),\n            sharedY: z.optional(z.boolean()),\n            nRows: z.optional(z.number()),\n            nCols: z.optional(z.number()),\n        })\n    ),\n    keyColumn: ColumnNameSchema,\n    x: ColumnNameSchema,\n    y: ColumnNameSchema,\n    xAxis: z.optional(AxisSettingsSchema),\n    yAxis: z.optional(AxisSettingsSchema),\n    grouping: z.optional(z.array(ColumnNameSchema)),\n    facetBy: z.optional(z.array(ColumnNameSchema)),\n    label: z.optional(ColumnNameSchema),\n    highlight: z.optional(ColumnNameSchema),\n    inheritedAes: z.optional(z.record(z.string(), AesMapSchema)),\n    trend: z.optional(\n        z.object({\n            color: z.optional(z.optional(z.union([z.string(), InheritAesSchema, continuousAesMappingFromValueSchema(z.string())]))),\n            bounded: z.optional(z.boolean()), // if true: line and area bounded with min and max X value; else line bounded by chart bounds\n        })\n    ),\n    layers: z.array(ScatterplotLayerSchema),\n});\n\nexport type ScatterplotSettings = z.infer<typeof ScatterplotSettingsSchema>;\n\nexport type ScatterplotLegendInfo = Record<\n    string,\n    {\n        values: string[];\n        usedAes: (keyof AesItem)[];\n        aesMap: AesMap;\n        labels: Record<string, string>;\n    }\n>;\n"],"names":["InheritAesSchema","z","DotsLayerSchema","continuousAesMappingFromValueSchema","PointShapeSchema","CurveLayerSchema","LineShapeSchema","ScatterplotLayerSchema","ScatterplotSettingsSchema","TitlePositionSchema","LegendPositionSchema","ColumnNameSchema","FrameTypeSchema","AxisSettingsSchema","AesMapSchema"],"mappings":"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"}
+{"version":3,"file":"scatterplot.js","sources":["../../src/types/scatterplot.ts"],"sourcesContent":["import { z } from 'zod';\nimport type { AesItem, categoricalAesMappingFromValueSchema, Category, DataValue } from './common';\nimport {\n    AesRecordSchema, AxisSettingsSchema,\n    ColumnNameSchema,\n    continuousAesMappingFromValueSchema,\n    FrameTypeSchema,\n    LegendPositionSchema,\n    LineShapeSchema,\n    PointShapeSchema,\n    TitlePositionSchema\n} from './common';\n\ntype catAesFromColumn<ValueType extends z.ZodType> = ReturnType<typeof categoricalAesMappingFromValueSchema<ValueType>>;\ntype contAesFromColumn<ValueType extends z.ZodType> = ReturnType<typeof continuousAesMappingFromValueSchema<ValueType>>;\n\nexport type CategoricalAesFromColumn<ValueType> = z.infer<catAesFromColumn<z.ZodType<ValueType>>>;\nexport type ContinuousAesFromColumn<ValueType> = z.infer<contAesFromColumn<z.ZodType<ValueType>>>;\n\nconst InheritAesSchema = z.object({\n    type: z.literal('grouping'),\n    value: z.string(), // link to aes mapped to column\n    palette: z.optional(z.array(z.string())) // if defined we use palette to create mapping without inheritedAes field\n});\nexport type InheritAesScatterplot = z.infer<typeof InheritAesSchema>;\n\nconst DotsLayerSchema = z.object({\n    type: z.literal('dots'),\n    aes: z.optional(\n        z.object({\n            dotFill: z.optional(z.union([z.string(), InheritAesSchema, continuousAesMappingFromValueSchema(z.string())])),\n            dotShape: z.optional(z.union([PointShapeSchema, InheritAesSchema])),\n            dotSize: z.optional(z.union([z.number(), continuousAesMappingFromValueSchema(z.number())])),\n        })\n    ),\n});\nconst CurveLayerSchema = z.object({\n    type: z.literal('curve'),\n    smoothing: z.optional(z.boolean()),\n    aes: z.optional(\n        z.object({\n            lineWidth: z.optional(z.number()),\n            lineShape: z.optional(LineShapeSchema),\n            lineColor: z.optional(z.union([z.string(), InheritAesSchema, continuousAesMappingFromValueSchema(z.string())])),\n            opacity: z.optional(z.number()),\n        })\n    ),\n});\nconst ScatterplotLayerSchema = z.union([DotsLayerSchema, CurveLayerSchema]);\n\nexport type DotsLayer = z.infer<typeof DotsLayerSchema>;\nexport type CurveLayer = z.infer<typeof CurveLayerSchema>;\nexport type ScatterplotLayer = z.infer<typeof ScatterplotLayerSchema>;\n\nexport const ScatterplotSettingsSchema = z.object({\n    type: z.literal('scatterplot'),\n    title: z.object({\n        name: z.string(),\n        show: z.optional(z.boolean()),\n        position: z.optional(TitlePositionSchema),\n    }),\n    size: z.optional(\n        z.object({\n            width: z.optional(z.number()),\n            height: z.optional(z.number()),\n        })\n    ),\n    legend: z.optional(\n        z.object({\n            show: z.optional(z.boolean()),\n            position: z.optional(LegendPositionSchema),\n        })\n    ),\n    tooltips: z.optional(\n        z.object({\n            show: z.optional(z.boolean()),\n            content: z.optional(z.array(ColumnNameSchema)),\n        })\n    ),\n    frame: z.optional(z.object({type: z.optional(FrameTypeSchema)})),\n    facetSettings: z.optional(\n        z.object({\n            sharedX: z.optional(z.boolean()),\n            sharedY: z.optional(z.boolean()),\n            nRows: z.optional(z.number()),\n            nCols: z.optional(z.number()),\n        })\n    ),\n    keyColumn: ColumnNameSchema,\n    x: ColumnNameSchema,\n    y: ColumnNameSchema,\n    xAxis: z.optional(AxisSettingsSchema),\n    yAxis: z.optional(AxisSettingsSchema),\n    grouping: z.optional(z.array(ColumnNameSchema)),\n    facetBy: z.optional(z.array(ColumnNameSchema)),\n    label: z.optional(ColumnNameSchema),\n    highlight: z.optional(ColumnNameSchema),\n    inheritedAes: z.optional(z.record(z.string(), AesRecordSchema)),\n    trend: z.optional(\n        z.object({\n            color: z.optional(z.optional(z.union([z.string(), InheritAesSchema, continuousAesMappingFromValueSchema(z.string())]))),\n            bounded: z.optional(z.boolean()), // if true: line and area bounded with min and max X value; else line bounded by chart bounds\n        })\n    ),\n    layers: z.array(ScatterplotLayerSchema),\n});\n\nexport type ScatterplotSettings = z.infer<typeof ScatterplotSettingsSchema>;\n\nexport type ScatterplotLegendInfo = Record<\n    string,\n    {\n        values: Category[];\n        usedAes: (keyof AesItem)[];\n        aesMap: (value: Category, field: keyof AesItem) => undefined | DataValue;\n        labels: Record<Category, string>;\n    }\n>;\n"],"names":["InheritAesSchema","z","DotsLayerSchema","continuousAesMappingFromValueSchema","PointShapeSchema","CurveLayerSchema","LineShapeSchema","ScatterplotLayerSchema","ScatterplotSettingsSchema","TitlePositionSchema","LegendPositionSchema","ColumnNameSchema","FrameTypeSchema","AxisSettingsSchema","AesRecordSchema"],"mappings":"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"}

package/dist/utils/TextMeasurer/TextMeasurer.d.ts

@@ -0,0 +1,7 @@
+export declare class TextMeasurer {
+    private ctx;
+    constructor(font?: string);
+    getTextMetrics(text: string): TextMetrics;
+    getTextWidth(text: string): number;
+}
+//# sourceMappingURL=TextMeasurer.d.ts.map

package/dist/utils/TextMeasurer/TextMeasurer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextMeasurer.d.ts","sourceRoot":"","sources":["../../../src/utils/TextMeasurer/TextMeasurer.tsx"],"names":[],"mappings":"AAGA,qBAAa,YAAY;IACrB,OAAO,CAAC,GAAG,CAA2B;gBAE1B,IAAI,SAAiB;IAmBjC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;IAIzC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAGrC"}

package/dist/utils/TextMeasurer/TextMeasurer.js

@@ -0,0 +1,42 @@
+var i = Object.defineProperty;
+var a = (r, t, e) => t in r ? i(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var c = (r, t, e) => a(r, typeof t != "symbol" ? t + "" : t, e);
+import { l as h } from "../../node_modules/lodash/lodash.js";
+import x from "./charToWidth.json.js";
+class T {
+  constructor(t = "14px Manrope") {
+    c(this, "ctx");
+    if (!document)
+      throw new Error("TextMeasurer requires a document to create a canvas");
+    const e = document.createElement("canvas"), o = e.getContext("2d");
+    if (!o)
+      throw new Error("Failed to get canvas context");
+    e.width = 500, e.height = 30, o.font = t, this.ctx = o;
+  }
+  getTextMetrics(t) {
+    return u(this.ctx, t);
+  }
+  getTextWidth(t) {
+    return this.getTextMetrics(t).width;
+  }
+}
+const d = x, u = h.memoize(
+  (r, t) => r.measureText(t),
+  (r, t) => {
+    let e = 0;
+    for (let n = 0; n < t.length; n++)
+      e += d[t[n]] ?? 70;
+    const o = e % 5, s = o > 2 ? e - o + 5 : e;
+    return m(r.font) + s;
+  }
+);
+function m(r) {
+  let t = 0;
+  for (let e = 0; e < r.length; e++)
+    t = t * 31 + r.charCodeAt(e) >>> 0;
+  return t;
+}
+export {
+  T as TextMeasurer
+};
+//# sourceMappingURL=TextMeasurer.js.map

package/dist/utils/TextMeasurer/TextMeasurer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextMeasurer.js","sources":["../../../src/utils/TextMeasurer/TextMeasurer.tsx"],"sourcesContent":["import { memoize } from 'lodash';\nimport charToWidthJson from './charToWidth.json' with { type: 'json' };\n\nexport class TextMeasurer {\n    private ctx: CanvasRenderingContext2D;\n\n    constructor(font = '14px Manrope') {\n        if (!document) {\n            throw new Error('TextMeasurer requires a document to create a canvas');   \n        }\n\n        const canvas = document.createElement('canvas');\n        const ctx = canvas.getContext('2d');\n\n        if (!ctx) {\n            throw new Error('Failed to get canvas context');\n        }\n\n        canvas.width = 500;\n        canvas.height = 30;\n        ctx.font = font;\n        \n        this.ctx = ctx;\n    }\n\n    getTextMetrics(text: string): TextMetrics {\n        return getTextMetrics(this.ctx, text);\n    }\n\n    getTextWidth(text: string): number {\n        return this.getTextMetrics(text).width;\n    }\n}\n\nconst charToWidth: Record<string, number> = charToWidthJson;\nconst getTextMetrics = memoize(\n    (ctx: CanvasRenderingContext2D, text: string): TextMetrics => ctx.measureText(text),\n    ((ctx, text) => {\n        let width = 0;\n        for (let i = 0; i < text.length; i++) {\n            width += charToWidth[text[i]] ?? 70;\n        }\n        const restOfFive = width % 5;\n        const approximateWidth = restOfFive > 2 ? width - restOfFive + 5 : width;\n        return hashString(ctx.font) + approximateWidth;\n    })\n);\n\nfunction hashString(s: string): number {\n  let h = 0;\n  for (let i = 0; i < s.length; i++) {\n    h = (h * 31 + s.charCodeAt(i)) >>> 0;\n  }\n  return h;\n}"],"names":["TextMeasurer","font","__publicField","canvas","ctx","text","getTextMetrics","charToWidth","charToWidthJson","memoize","width","i","restOfFive","approximateWidth","hashString","s","h"],"mappings":";;;;;AAGO,MAAMA,EAAa;AAAA,EAGtB,YAAYC,IAAO,gBAAgB;AAF3B,IAAAC,EAAA;AAGJ,QAAI,CAAC;AACD,YAAM,IAAI,MAAM,qDAAqD;AAGzE,UAAMC,IAAS,SAAS,cAAc,QAAQ,GACxCC,IAAMD,EAAO,WAAW,IAAI;AAElC,QAAI,CAACC;AACD,YAAM,IAAI,MAAM,8BAA8B;AAGlD,IAAAD,EAAO,QAAQ,KACfA,EAAO,SAAS,IAChBC,EAAI,OAAOH,GAEX,KAAK,MAAMG;AAAA,EACf;AAAA,EAEA,eAAeC,GAA2B;AACtC,WAAOC,EAAe,KAAK,KAAKD,CAAI;AAAA,EACxC;AAAA,EAEA,aAAaA,GAAsB;AAC/B,WAAO,KAAK,eAAeA,CAAI,EAAE;AAAA,EACrC;AACJ;AAEA,MAAME,IAAsCC,GACtCF,IAAiBG,EAAAA;AAAAA,EACnB,CAACL,GAA+BC,MAA8BD,EAAI,YAAYC,CAAI;AAAA,EACjF,CAACD,GAAKC,MAAS;AACZ,QAAIK,IAAQ;AACZ,aAASC,IAAI,GAAGA,IAAIN,EAAK,QAAQM;AAC7B,MAAAD,KAASH,EAAYF,EAAKM,CAAC,CAAC,KAAK;AAErC,UAAMC,IAAaF,IAAQ,GACrBG,IAAmBD,IAAa,IAAIF,IAAQE,IAAa,IAAIF;AACnE,WAAOI,EAAWV,EAAI,IAAI,IAAIS;AAAA,EAClC;AACJ;AAEA,SAASC,EAAWC,GAAmB;AACrC,MAAIC,IAAI;AACR,WAASL,IAAI,GAAGA,IAAII,EAAE,QAAQJ;AAC5B,IAAAK,IAAKA,IAAI,KAAKD,EAAE,WAAWJ,CAAC,MAAO;AAErC,SAAOK;AACT;"}

package/dist/utils/TextMeasurer/charToWidth.json.js

@@ -0,0 +1,155 @@
+const o = 61, t = 63, s = 55, c = 63, n = 62, a = 38, d = 63, e = 63, h = 28, r = 30, f = 58, i = 28, l = 97, p = 63, u = 61, x = 63, J = 63, T = 42, W = 52, b = 39, g = 63, j = 59, k = 82, m = 59, q = 59, v = 52, w = 68, y = 69, z = 70, A = 77, B = 63, C = 58, D = 77, E = 75, F = 30, G = 36, H = 68, I = 56, K = 86, L = 75, M = 79, N = 60, O = 79, P = 69, Q = 63, R = 63, S = 73, U = 68, V = 99, X = 69, Y = 63, Z = 69, _ = 64, $ = 52, oo = {
+  0: 64,
+  1: 64,
+  2: 64,
+  3: 64,
+  4: 64,
+  5: 64,
+  6: 64,
+  7: 64,
+  8: 64,
+  9: 64,
+  a: 61,
+  b: 63,
+  c: 55,
+  d: 63,
+  e: 62,
+  f: 38,
+  g: 63,
+  h: 63,
+  i: 28,
+  j: 30,
+  k: 58,
+  l: 28,
+  m: 97,
+  n: 63,
+  o: 61,
+  p: 63,
+  q: 63,
+  r: 42,
+  s: 52,
+  t: 39,
+  u: 63,
+  v: 59,
+  w: 82,
+  x: 59,
+  y: 59,
+  z: 52,
+  A: 68,
+  B: 69,
+  C: 70,
+  D: 77,
+  E: 63,
+  F: 58,
+  G: 77,
+  H: 75,
+  I: 30,
+  J: 36,
+  K: 68,
+  L: 56,
+  M: 86,
+  N: 75,
+  O: 79,
+  P: 60,
+  Q: 79,
+  R: 69,
+  S: 63,
+  T: 63,
+  U: 73,
+  V: 68,
+  W: 99,
+  X: 69,
+  Y: 63,
+  Z: 69,
+  "!": 40,
+  '"': 46,
+  "#": 84,
+  $: 64,
+  "%": 95,
+  "&": 78,
+  "'": 27,
+  "(": 39,
+  ")": 39,
+  "*": 50,
+  "+": 84,
+  ",": 32,
+  "-": 36,
+  ".": 32,
+  "/": 34,
+  ":": 34,
+  ";": 34,
+  "<": 84,
+  "=": 84,
+  ">": 84,
+  "?": 53,
+  "@": 100,
+  "[": 39,
+  "\\": 34,
+  "]": 39,
+  "^": 84,
+  _: 52,
+  "`": 50,
+  "{": 64,
+  "|": 34,
+  "}": 64,
+  "~": 84,
+  " ": 32
+};
+export {
+  _ as $,
+  w as A,
+  y as B,
+  z as C,
+  A as D,
+  B as E,
+  C as F,
+  D as G,
+  E as H,
+  F as I,
+  G as J,
+  H as K,
+  I as L,
+  K as M,
+  L as N,
+  M as O,
+  N as P,
+  O as Q,
+  P as R,
+  Q as S,
+  R as T,
+  S as U,
+  U as V,
+  V as W,
+  X,
+  Y,
+  Z,
+  $ as _,
+  o as a,
+  t as b,
+  s as c,
+  c as d,
+  oo as default,
+  n as e,
+  a as f,
+  d as g,
+  e as h,
+  h as i,
+  r as j,
+  f as k,
+  i as l,
+  l as m,
+  p as n,
+  u as o,
+  x as p,
+  J as q,
+  T as r,
+  W as s,
+  b as t,
+  g as u,
+  j as v,
+  k as w,
+  m as x,
+  q as y,
+  v as z
+};
+//# sourceMappingURL=charToWidth.json.js.map

package/dist/utils/TextMeasurer/charToWidth.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"charToWidth.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/utils/arrangeLegendParts.js

@@ -1,4 +1,4 @@
-import { TextMeasurer as U } from "./TextMeasurer.js";
+import { TextMeasurer as U } from "./TextMeasurer/TextMeasurer.js";
 import { getContinuousLegendWidth as $ } from "./getLegendWidth.js";
 const O = new U("600 14px Manrope"), z = 16, W = 48, A = 20, f = 24;
 function _(a, o) {

package/dist/utils/arrangeLegendParts.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrangeLegendParts.js","sources":["../../src/utils/arrangeLegendParts.ts"],"sourcesContent":["import type { LegendItem } from '../common/types';\nimport { TextMeasurer } from './TextMeasurer';\nimport { getContinuousLegendWidth } from './getLegendWidth';\n\nconst textMeasurer = new TextMeasurer('600 14px Manrope');\nconst LINE_HEIGHT = 16;\nconst GROUP_OFFSET = 48;\nconst TEXT_LEFT_DISCRETE = 20;\nconst COLUMN_OFFSET = 24;\n\nfunction getLegendItemWidth(keys: string[], title: string) {\n    return Math.max(\n        ...keys.map(text => textMeasurer.getTextWidth(String(text)) + TEXT_LEFT_DISCRETE),\n        textMeasurer.getTextWidth(title)\n    );\n}\n\nfunction splitLegendPart<T extends string | number>(values:T[], firstPartHeight:number, maxHeight:number, lineHeight: number):T[][] {\n    const parts:T[][] = [[]];\n    let currentPartHeight = 0;\n    let currentAvailableHeight = firstPartHeight;\n    let partIdx = 0;\n    values.forEach(v => {\n        if (currentPartHeight + lineHeight <= currentAvailableHeight) {\n            parts[partIdx].push(v);\n            currentPartHeight += lineHeight;\n        } else {\n            parts.push([v]);\n            partIdx++;\n            currentPartHeight = lineHeight;\n            currentAvailableHeight = maxHeight;\n        }\n    });\n    return parts;\n}\n\nexport function arrangeLegendParts(legendItems: LegendItem[], maxHeight:number, continuousHeight?:number):LegendItem[] {\n    const continuousItemHeight = continuousHeight ?? maxHeight;\n    let currentColumnWidth = 0;\n    let currentColumnHeight = 0;\n    let currentLeft = 0;\n    // continuous bars on the left, then discrete lists, then sizes\n    legendItems.sort((item1, item2) => {\n        if (item1.type === 'continuous' && item2.type !== 'continuous') {\n            return -1;\n        }\n        if (item2.type === 'continuous' && item1.type !== 'continuous') {\n            return 1;\n        }\n        if (item1.type === 'dots' && item2.type !== 'dots') {\n            return -1;\n        }\n        if (item2.type === 'dots' && item1.type !== 'dots') {\n            return 1;\n        }\n        return 0;\n    });\n\n    const updatedLegendItems:LegendItem[] = [];\n    legendItems.forEach((item) => {\n        const {type, values, title, id, scale} = item;\n        if (type === 'continuous') {\n            const width =  getContinuousLegendWidth(values, title);\n            const height = continuousItemHeight;\n\n            const verticalRest = maxHeight - currentColumnHeight;\n            if (verticalRest < height) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            const left = currentLeft;\n            const top = currentColumnHeight;\n            if (width > currentColumnWidth) {\n                currentColumnWidth = width;\n            }\n            currentColumnHeight += height + GROUP_OFFSET;\n            if (currentColumnHeight >= maxHeight) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n \n            updatedLegendItems.push({...item, width, height, left, top});\n        } else if (type === 'size') {\n            const {labels} = item;\n            const lineHeight = (scale(Math.max(...values)) * 2 + 4);\n            const width = getLegendItemWidth(values.map(v => labels[v]), title);\n            const height = values.length * lineHeight;\n\n            const verticalRest = maxHeight - currentColumnHeight;\n            if (verticalRest < height) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            const left = currentLeft;\n            const top = currentColumnHeight;\n            if (width > currentColumnWidth) {\n                currentColumnWidth = width;\n            }\n            currentColumnHeight += height + GROUP_OFFSET;\n            if (currentColumnHeight >= maxHeight) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            updatedLegendItems.push({...item, width, height, left, top});\n        } else {\n            const {labels} = item;\n            const lineHeight = LINE_HEIGHT;\n\n            let verticalRest = maxHeight - currentColumnHeight;\n            if (verticalRest < lineHeight) {\n                verticalRest = maxHeight;\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            // split values under one title into several columns if too many values\n            const groupedValues = splitLegendPart<typeof values[0]>(values, verticalRest, maxHeight, lineHeight);\n\n            const titleWidth = getLegendItemWidth([], title);\n\n            const startFromTheTop = currentColumnWidth === 0;\n            const leftByTitle = currentLeft + titleWidth + COLUMN_OFFSET; // for very wide titles; we don't want include title width to first column width; but if the title is too wide we move it after all column parts;\n            groupedValues.forEach((valuesPart, idx) => {\n                const last = idx === groupedValues.length - 1;\n                const partTitle = idx > 0 ? '' : title;\n                const partId = idx > 0 ? `${id}_${idx}` : id;\n                const width = getLegendItemWidth(valuesPart.map(v => labels[v]), startFromTheTop && !last ? '' : partTitle);\n                const height = valuesPart.length * lineHeight;\n                const left = currentLeft;\n                const top = currentColumnHeight;\n                if (width > currentColumnWidth) {\n                    currentColumnWidth = width;\n                }\n                if (last) {\n                    currentColumnHeight += height + GROUP_OFFSET;\n                } else {\n                    currentColumnHeight = maxHeight;\n                }\n                if (currentColumnHeight >= maxHeight) {\n                    currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                    if (startFromTheTop && last && currentLeft < leftByTitle) {\n                        currentLeft = leftByTitle;\n                    }\n                    currentColumnWidth = 0;\n                    currentColumnHeight = 0;\n                }\n                updatedLegendItems.push({...item, id: partId, title: partTitle, width, height, left, top, values: valuesPart} as LegendItem);\n            });\n        }\n    });\n    return updatedLegendItems;\n}"],"names":["textMeasurer","TextMeasurer","LINE_HEIGHT","GROUP_OFFSET","TEXT_LEFT_DISCRETE","COLUMN_OFFSET","getLegendItemWidth","keys","title","text","splitLegendPart","values","firstPartHeight","maxHeight","lineHeight","parts","currentPartHeight","currentAvailableHeight","partIdx","v","arrangeLegendParts","legendItems","continuousHeight","continuousItemHeight","currentColumnWidth","currentColumnHeight","currentLeft","item1","item2","updatedLegendItems","item","type","id","scale","width","getContinuousLegendWidth","height","left","top","labels","verticalRest","groupedValues","titleWidth","startFromTheTop","leftByTitle","valuesPart","idx","last","partTitle","partId"],"mappings":"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"}
+{"version":3,"file":"arrangeLegendParts.js","sources":["../../src/utils/arrangeLegendParts.ts"],"sourcesContent":["import type { LegendItem } from '../common/types';\nimport { TextMeasurer } from './TextMeasurer/TextMeasurer';\nimport { getContinuousLegendWidth } from './getLegendWidth';\n\nconst textMeasurer = new TextMeasurer('600 14px Manrope');\nconst LINE_HEIGHT = 16;\nconst GROUP_OFFSET = 48;\nconst TEXT_LEFT_DISCRETE = 20;\nconst COLUMN_OFFSET = 24;\n\nfunction getLegendItemWidth(keys: string[], title: string) {\n    return Math.max(\n        ...keys.map(text => textMeasurer.getTextWidth(String(text)) + TEXT_LEFT_DISCRETE),\n        textMeasurer.getTextWidth(title)\n    );\n}\n\nfunction splitLegendPart<T extends string | number>(values: T[], firstPartHeight: number, maxHeight: number, lineHeight: number):T[][] {\n    const parts:T[][] = [[]];\n    let currentPartHeight = 0;\n    let currentAvailableHeight = firstPartHeight;\n    let partIdx = 0;\n    values.forEach(v => {\n        if (currentPartHeight + lineHeight <= currentAvailableHeight) {\n            parts[partIdx].push(v);\n            currentPartHeight += lineHeight;\n        } else {\n            parts.push([v]);\n            partIdx++;\n            currentPartHeight = lineHeight;\n            currentAvailableHeight = maxHeight;\n        }\n    });\n    return parts;\n}\n\nexport function arrangeLegendParts(legendItems: LegendItem[], maxHeight:number, continuousHeight?:number):LegendItem[] {\n    const continuousItemHeight = continuousHeight ?? maxHeight;\n    let currentColumnWidth = 0;\n    let currentColumnHeight = 0;\n    let currentLeft = 0;\n    // continuous bars on the left, then discrete lists, then sizes\n    legendItems.sort((item1, item2) => {\n        if (item1.type === 'continuous' && item2.type !== 'continuous') {\n            return -1;\n        }\n        if (item2.type === 'continuous' && item1.type !== 'continuous') {\n            return 1;\n        }\n        if (item1.type === 'dots' && item2.type !== 'dots') {\n            return -1;\n        }\n        if (item2.type === 'dots' && item1.type !== 'dots') {\n            return 1;\n        }\n        return 0;\n    });\n\n    const updatedLegendItems:LegendItem[] = [];\n    legendItems.forEach((item) => {\n        const {type, values, title, id, scale} = item;\n        if (type === 'continuous') {\n            const width =  getContinuousLegendWidth(values, title);\n            const height = continuousItemHeight;\n\n            const verticalRest = maxHeight - currentColumnHeight;\n            if (verticalRest < height) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            const left = currentLeft;\n            const top = currentColumnHeight;\n            if (width > currentColumnWidth) {\n                currentColumnWidth = width;\n            }\n            currentColumnHeight += height + GROUP_OFFSET;\n            if (currentColumnHeight >= maxHeight) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n \n            updatedLegendItems.push({...item, width, height, left, top});\n        } else if (type === 'size') {\n            const {labels} = item;\n            const lineHeight = (scale(Math.max(...values)) * 2 + 4);\n            const width = getLegendItemWidth(values.map(v => labels[v]), title);\n            const height = values.length * lineHeight;\n\n            const verticalRest = maxHeight - currentColumnHeight;\n            if (verticalRest < height) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            const left = currentLeft;\n            const top = currentColumnHeight;\n            if (width > currentColumnWidth) {\n                currentColumnWidth = width;\n            }\n            currentColumnHeight += height + GROUP_OFFSET;\n            if (currentColumnHeight >= maxHeight) {\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            updatedLegendItems.push({...item, width, height, left, top});\n        } else {\n            const {labels} = item;\n            const lineHeight = LINE_HEIGHT;\n\n            let verticalRest = maxHeight - currentColumnHeight;\n            if (verticalRest < lineHeight) {\n                verticalRest = maxHeight;\n                currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                currentColumnWidth = 0;\n                currentColumnHeight = 0;\n            }\n            // split values under one title into several columns if too many values\n            const groupedValues = splitLegendPart<typeof values[number]>(values, verticalRest, maxHeight, lineHeight);\n\n            const titleWidth = getLegendItemWidth([], title);\n\n            const startFromTheTop = currentColumnWidth === 0;\n            const leftByTitle = currentLeft + titleWidth + COLUMN_OFFSET; // for very wide titles; we don't want include title width to first column width; but if the title is too wide we move it after all column parts;\n            groupedValues.forEach((valuesPart, idx) => {\n                const last = idx === groupedValues.length - 1;\n                const partTitle = idx > 0 ? '' : title;\n                const partId = idx > 0 ? `${id}_${idx}` : id;\n                const width = getLegendItemWidth(valuesPart.map(v => labels[v]), startFromTheTop && !last ? '' : partTitle);\n                const height = valuesPart.length * lineHeight;\n                const left = currentLeft;\n                const top = currentColumnHeight;\n                if (width > currentColumnWidth) {\n                    currentColumnWidth = width;\n                }\n                if (last) {\n                    currentColumnHeight += height + GROUP_OFFSET;\n                } else {\n                    currentColumnHeight = maxHeight;\n                }\n                if (currentColumnHeight >= maxHeight) {\n                    currentLeft += currentColumnWidth + COLUMN_OFFSET;\n                    if (startFromTheTop && last && currentLeft < leftByTitle) {\n                        currentLeft = leftByTitle;\n                    }\n                    currentColumnWidth = 0;\n                    currentColumnHeight = 0;\n                }\n                updatedLegendItems.push({...item, id: partId, title: partTitle, width, height, left, top, values: valuesPart} as LegendItem);\n            });\n        }\n    });\n    return updatedLegendItems;\n}"],"names":["textMeasurer","TextMeasurer","LINE_HEIGHT","GROUP_OFFSET","TEXT_LEFT_DISCRETE","COLUMN_OFFSET","getLegendItemWidth","keys","title","text","splitLegendPart","values","firstPartHeight","maxHeight","lineHeight","parts","currentPartHeight","currentAvailableHeight","partIdx","v","arrangeLegendParts","legendItems","continuousHeight","continuousItemHeight","currentColumnWidth","currentColumnHeight","currentLeft","item1","item2","updatedLegendItems","item","type","id","scale","width","getContinuousLegendWidth","height","left","top","labels","verticalRest","groupedValues","titleWidth","startFromTheTop","leftByTitle","valuesPart","idx","last","partTitle","partId"],"mappings":"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"}

package/dist/utils/getChartEdgeSides.d.ts

@@ -1,2 +1,2 @@
-export declare function getChartEdgeSides(index: number, facetsCount: number, columnsCount: number, rowsCount: number): ("left" | "right" | "top" | "bottom")[];
+export declare function getChartEdgeSides(index: number, facetsCount: number, columnsCount: number, rowsCount: number): ("right" | "left" | "top" | "bottom")[];
 //# sourceMappingURL=getChartEdgeSides.d.ts.map

package/dist/utils/getLegendWidth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLegendWidth.d.ts","sourceRoot":"","sources":["../../src/utils/getLegendWidth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,UAAU,CAAC;AAK3C,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAK3E;AACD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,UAKxF"}
+{"version":3,"file":"getLegendWidth.d.ts","sourceRoot":"","sources":["../../src/utils/getLegendWidth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAM7C,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAK3E;AACD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,UAKxF"}

package/dist/utils/getLegendWidth.js

@@ -1,4 +1,4 @@
-import { TextMeasurer as r } from "./TextMeasurer.js";
+import { TextMeasurer as r } from "./TextMeasurer/TextMeasurer.js";
 const t = new r("bold 14px Arial"), T = 20, o = 24;
 function d(e, n) {
   return Math.max(

package/dist/utils/getLegendWidth.js.map

@@ -1 +1 @@
-{"version":3,"file":"getLegendWidth.js","sources":["../../src/utils/getLegendWidth.ts"],"sourcesContent":["import {TextMeasurer} from './TextMeasurer';\nimport type {ScaleOrdinal} from 'd3-scale';\n\nconst textMeasurer = new TextMeasurer('bold 14px Arial');\nconst TEXT_LEFT_DISCRETE = 20;\nconst TEXT_LEFT_CONTINUOUS = 24;\nexport function getContinuousLegendWidth(scaleTicks: number[], title: string) {\n    return Math.max(\n        ...scaleTicks.map(text => textMeasurer.getTextWidth(String(text)) + TEXT_LEFT_CONTINUOUS),\n        textMeasurer.getTextWidth(title)\n    );\n}\nexport function getDiscreteLegendWidth(scale: ScaleOrdinal<string, string>, title: string) {\n    return Math.max(\n        ...scale.domain().map(text => textMeasurer.getTextWidth(String(text)) + TEXT_LEFT_DISCRETE),\n        textMeasurer.getTextWidth(title)\n    );\n}"],"names":["textMeasurer","TextMeasurer","TEXT_LEFT_DISCRETE","TEXT_LEFT_CONTINUOUS","getContinuousLegendWidth","scaleTicks","title","text","getDiscreteLegendWidth","scale"],"mappings":";AAGA,MAAMA,IAAe,IAAIC,EAAa,iBAAiB,GACjDC,IAAqB,IACrBC,IAAuB;AACtB,SAASC,EAAyBC,GAAsBC,GAAe;AAC1E,SAAO,KAAK;AAAA,IACR,GAAGD,EAAW,IAAI,CAAAE,MAAQP,EAAa,aAAa,OAAOO,CAAI,CAAC,IAAIJ,CAAoB;AAAA,IACxFH,EAAa,aAAaM,CAAK;AAAA,EAAA;AAEvC;AACO,SAASE,EAAuBC,GAAqCH,GAAe;AACvF,SAAO,KAAK;AAAA,IACR,GAAGG,EAAM,SAAS,IAAI,CAAAF,MAAQP,EAAa,aAAa,OAAOO,CAAI,CAAC,IAAIL,CAAkB;AAAA,IAC1FF,EAAa,aAAaM,CAAK;AAAA,EAAA;AAEvC;"}
+{"version":3,"file":"getLegendWidth.js","sources":["../../src/utils/getLegendWidth.ts"],"sourcesContent":["import type { ScaleOrdinal } from 'd3-scale';\nimport { TextMeasurer } from './TextMeasurer/TextMeasurer';\n\nconst textMeasurer = new TextMeasurer('bold 14px Arial');\nconst TEXT_LEFT_DISCRETE = 20;\nconst TEXT_LEFT_CONTINUOUS = 24;\nexport function getContinuousLegendWidth(scaleTicks: number[], title: string) {\n    return Math.max(\n        ...scaleTicks.map(text => textMeasurer.getTextWidth(String(text)) + TEXT_LEFT_CONTINUOUS),\n        textMeasurer.getTextWidth(title)\n    );\n}\nexport function getDiscreteLegendWidth(scale: ScaleOrdinal<string, string>, title: string) {\n    return Math.max(\n        ...scale.domain().map(text => textMeasurer.getTextWidth(String(text)) + TEXT_LEFT_DISCRETE),\n        textMeasurer.getTextWidth(title)\n    );\n}"],"names":["textMeasurer","TextMeasurer","TEXT_LEFT_DISCRETE","TEXT_LEFT_CONTINUOUS","getContinuousLegendWidth","scaleTicks","title","text","getDiscreteLegendWidth","scale"],"mappings":";AAGA,MAAMA,IAAe,IAAIC,EAAa,iBAAiB,GACjDC,IAAqB,IACrBC,IAAuB;AACtB,SAASC,EAAyBC,GAAsBC,GAAe;AAC1E,SAAO,KAAK;AAAA,IACR,GAAGD,EAAW,IAAI,CAAAE,MAAQP,EAAa,aAAa,OAAOO,CAAI,CAAC,IAAIJ,CAAoB;AAAA,IACxFH,EAAa,aAAaM,CAAK;AAAA,EAAA;AAEvC;AACO,SAASE,EAAuBC,GAAqCH,GAAe;AACvF,SAAO,KAAK;AAAA,IACR,GAAGG,EAAM,SAAS,IAAI,CAAAF,MAAQP,EAAa,aAAa,OAAOO,CAAI,CAAC,IAAIL,CAAkB;AAAA,IAC1FF,EAAa,aAAaM,CAAK;AAAA,EAAA;AAEvC;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@milaboratories/miplots4",
-    "version": "1.0.129",
+    "version": "1.0.131",
     "description": "Data visualization library",
     "author": "erohinaelena",
     "license": "ISC",
@@ -38,9 +38,9 @@
         "@types/d3-array": "^3.2.1",
         "@types/d3-axis": "^3.0.6",
         "@types/d3-color": "^3.1.3",
+        "@types/d3-drag": "^3.0.7",
         "@types/d3-format": "^3.0.4",
         "@types/d3-hierarchy": "^3.1.7",
-        "@types/d3-drag": "^3.0.7",
         "@types/d3-polygon": "^3.0.2",
         "@types/d3-quadtree": "^3.0.6",
         "@types/d3-random": "^3.0.3",
@@ -48,6 +48,7 @@
         "@types/d3-selection": "^3.0.10",
         "@types/d3-shape": "^3.1.6",
         "@types/d3-zoom": "^3.0.8",
+        "@types/kdbush": "^3.0.5",
         "@types/lodash": "^4.17.9",
         "@types/node": "18.15.3",
         "@types/rbush": "^4.0.0",
@@ -66,6 +67,7 @@
         "d3-selection": "^3.0.0",
         "d3-shape": "^3.2.0",
         "d3-zoom": "^3.0.0",
+        "kdbush": "^4.0.2",
         "lodash": "^4.17.21",
         "rbush": "^4.0.1",
         "react": "^18.3.1",
@@ -93,4 +95,4 @@
         "vite-plugin-dts": "^4.2.4",
         "vitest": "^3.2.4"
     }
-}
+}

package/dist/bubble/getCells.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCells.d.ts","sourceRoot":"","sources":["../../src/bubble/getCells.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAC,UAAU,EAAE,SAAS,EAAsB,MAAM,UAAU,CAAC;AAkCzE,MAAM,MAAM,IAAI,GAAG;IACf,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,SAAS,CAAC;IACtB,mBAAmB,EAAE,SAAS,CAAC;IAC/B,oBAAoB,EAAE,SAAS,CAAC;IAChC,CAAC,EAAE,SAAS,CAAC;IACb,CAAC,EAAE,SAAS,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE;QACF,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACzC,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACtC,CAAC;IAEF,MAAM,EAAE,MAAM,CACV,MAAM,EACN;QAEI,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,KAAK,EAAE,MAAM,EAAE,CAAC;QAEhB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;KAC/C,CACJ,CAAC;CACL,CAAC;AAEF,wBAAgB,QAAQ,CACpB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,UAAU,EACnB,eAAe,EAAE,UAAU,EAC3B,gBAAgB,EAAE,UAAU,EAC5B,OAAO,EAAE,UAAU,EAAE,EACrB,qBAAqB,EAAE,MAAM,EAAE,EAAE,EACjC,aAAa,EAAE,kBAAkB,CAAC,eAAe,CAAC,EAClD,SAAS,EAAE,kBAAkB,CAAC,WAAW,CAAC,GAC3C,gBAAgB,CA4JlB"}

package/dist/bubble/getCells.js

@@ -1,91 +0,0 @@
-import I from "../node_modules/lodash/lodash.js";
-import _ from "../node_modules/d3-array/src/deviation.js";
-import $ from "../node_modules/d3-array/src/mean.js";
-import N from "../node_modules/d3-array/src/extent.js";
-const j = 1e6;
-function q(s) {
-  const o = _(s), r = $(s);
-  return o === void 0 || r === void 0 || o === 0 ? (i) => i : (i) => (i - r) / o;
-}
-function D(s) {
-  const o = $(s), [r, i] = N(s);
-  return o === void 0 || r === void 0 || i === void 0 ? (v) => v : (v) => (v - o) / (i - r);
-}
-function R(s, o) {
-  return s === "standardScaling" ? q(o) : s === "meanNormalization" ? D(o) : (r) => r;
-}
-function F(s, o, r, i, v, K, S, E, z) {
-  const g = S.map((t) => t.join("_")), e = {
-    meta: {
-      facetKeys: g,
-      xKeys: [],
-      yKeys: [],
-      xLabels: {},
-      yLabels: {},
-      facetKeyValues: g.reduce((t, a, n) => (t[a] = S[n], t), {}),
-      valueExtentSize: [1 / 0, -1 / 0],
-      valueExtentColor: [1 / 0, -1 / 0]
-    },
-    facets: {}
-  }, C = /* @__PURE__ */ new Set(), L = /* @__PURE__ */ new Set(), V = o.valueLabels ?? o.value, b = r.valueLabels ?? r.value;
-  if (s.rows.forEach((t) => {
-    const a = K.length ? K.map((h) => t[h.value]).join("_") : "null", n = t[o.value], l = t[r.value], c = t[i.value] ?? z, u = t[v.value] ?? z;
-    if (!(n === null || l === null || c === null || u === null)) {
-      if (e.facets[a] || (e.facets[a] = {
-        xKeys: [],
-        yKeys: [],
-        cells: {}
-      }), e.facets[a].xKeys.push(n), e.facets[a].yKeys.push(l), C.has(n) || (C.add(n), e.meta.xKeys.push(n)), L.has(l) || (L.add(l), e.meta.yKeys.push(l)), e.facets[a].cells[n] || (e.facets[a].cells[n] = {}), e.meta.valueExtentSize[0] = Math.min(c, e.meta.valueExtentSize[0]), e.meta.valueExtentSize[1] = Math.max(c, e.meta.valueExtentSize[1]), e.meta.valueExtentColor[0] = Math.min(u, e.meta.valueExtentColor[0]), e.meta.valueExtentColor[1] = Math.max(u, e.meta.valueExtentColor[1]), e.facets[a].cells[n][l])
-        throw Error(`More than 1 value for x=${n}, y=${l}`);
-      if (e.meta.xLabels[n] && String(t[V]) !== e.meta.xLabels[n])
-        throw Error(`More than 1 x-label value for x=${n}`);
-      if (e.meta.yLabels[l] && String(t[b]) !== e.meta.yLabels[l])
-        throw Error(`More than 1 y-label value for y=${l}`);
-      e.meta.xLabels[n] = String(t[V]), e.meta.yLabels[l] = String(t[b]), e.meta && (e.facets[a].cells[n][l] = {
-        id: `${n}_${l}`,
-        x: n,
-        y: l,
-        sizeValue: c,
-        normalizedSizeValue: c,
-        colorValue: u,
-        normalizedColorValue: u,
-        data: t
-      });
-    }
-  }), e.meta.facetKeys = e.meta.facetKeys.filter((t) => e.facets[t]), e.meta.facetKeys.forEach((t) => {
-    const a = e.facets[t];
-    if (a.xKeys = I.uniq(a.xKeys), a.yKeys = I.uniq(a.yKeys), a.xKeys.length * a.yKeys.length > j)
-      throw Error(`Too many cells for graph rendering (${a.xKeys.length * a.yKeys.length})`);
-  }), E) {
-    const t = [1 / 0, -1 / 0];
-    e.meta.facetKeys.forEach((a) => {
-      if (!e.facets[a])
-        return;
-      const { xKeys: n, yKeys: l, cells: c } = e.facets[a], u = E.direction === "row" ? n : l, h = E.direction === "row" ? l : n, p = E.direction === "row" ? (y, x) => {
-        var m;
-        return (m = c[y]) == null ? void 0 : m[x];
-      } : (y, x) => {
-        var m;
-        return (m = c[x]) == null ? void 0 : m[y];
-      };
-      h.forEach((y) => {
-        const x = [];
-        u.forEach((d) => {
-          var M;
-          const f = (M = p(d, y)) == null ? void 0 : M.colorValue;
-          f !== void 0 && x.push(f);
-        });
-        const m = R(E.method, x);
-        u.forEach((d) => {
-          const f = p(d, y);
-          f !== void 0 && (f.normalizedColorValue = m(f.colorValue), t[0] = Math.min(f.normalizedColorValue, t[0]), t[1] = Math.max(f.normalizedColorValue, t[1]));
-        });
-      });
-    }), e.meta.valueExtentColor = t;
-  }
-  return e.meta.valueExtentSize[0] === 1 / 0 && (e.meta.valueExtentSize[0] = 0), e.meta.valueExtentSize[1] === -1 / 0 && (e.meta.valueExtentSize[1] = 0), e.meta.valueExtentColor[0] === 1 / 0 && (e.meta.valueExtentColor[0] = 0), e.meta.valueExtentColor[1] === -1 / 0 && (e.meta.valueExtentColor[1] = 0), e;
-}
-export {
-  F as getCells
-};
-//# sourceMappingURL=getCells.js.map

package/dist/bubble/getCells.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getCells.js","sources":["../../src/bubble/getCells.ts"],"sourcesContent":["import type {BubbleSettingsImpl} from './BubbleSettingsImpl';\nimport type {DataFrame} from '../DataFrame';\nimport type {ColumnName, DataValue, NormalizationMethod} from '../types';\nimport {deviation, extent, mean} from 'd3-array';\nimport lodash from 'lodash';\n\nconst MAX_RENDERED_CELLS_COUNT = 1000000;\nfunction normalizeByStd(values: number[]) {\n    const stdValue = deviation(values);\n    const meanValue = mean(values);\n\n    if (stdValue === undefined || meanValue === undefined || stdValue === 0) {\n        return (v: number) => v;\n    }\n    return (v: number) => (v - meanValue) / stdValue;\n}\n\nfunction normalizeByMinMax(values: number[]) {\n    const meanValue = mean(values);\n    const [min, max] = extent(values);\n    if (meanValue === undefined || min === undefined || max === undefined) {\n        return (v: number) => v;\n    }\n    return (v: number) => (v - meanValue) / (max - min);\n}\n\nfunction getNormalizationFn(method: NormalizationMethod, values: number[]) {\n    if (method === 'standardScaling') {\n        return normalizeByStd(values);\n    }\n    if (method === 'meanNormalization') {\n        return normalizeByMinMax(values);\n    }\n    return (v: number) => v;\n}\n\nexport type Cell = {\n    id: string;\n    sizeValue: DataValue;\n    colorValue: DataValue;\n    normalizedSizeValue: DataValue;\n    normalizedColorValue: DataValue;\n    x: DataValue;\n    y: DataValue;\n    data: Record<string, DataValue>;\n};\n\nexport type GroupedCellsData = {\n    meta: {\n        facetKeys: string[];\n        facetKeyValues: Record<string, string[]>;\n        xKeys: string[]; // all the keys from facets\n        yKeys: string[]; // all the keys from facets\n        xLabels: Record<string, string>;\n        yLabels: Record<string, string>;\n        valueExtentSize: [number, number]; // for size scales\n        valueExtentColor: [number, number]; // for color scales\n    };\n    //facet groups\n    facets: Record<\n        string,\n        {\n            // axis keys\n            xKeys: string[];\n            yKeys: string[];\n            // cells grouped by X, then by Y\n            cells: Record<string, Record<string, Cell>>;\n        }\n    >;\n};\n\nexport function getCells(\n    data: DataFrame,\n    xColumn: ColumnName,\n    yColumn: ColumnName,\n    valueColumnSize: ColumnName,\n    valueColumnColor: ColumnName,\n    facetBy: ColumnName[],\n    facetKeysCombinations: string[][],\n    normalization: BubbleSettingsImpl['normalization'],\n    NAValueAs: BubbleSettingsImpl['NAValueAs']\n): GroupedCellsData {\n    const facetKeys = facetKeysCombinations.map(v => v.join('_'));\n    const result: GroupedCellsData = {\n        meta: {\n            facetKeys,\n            xKeys: [],\n            yKeys: [],\n            xLabels: {},\n            yLabels: {},\n            facetKeyValues: facetKeys.reduce((res: Record<string, string[]>, key, index) => {\n                res[key] = facetKeysCombinations[index];\n                return res;\n            }, {}),\n            valueExtentSize: [Infinity, -Infinity],\n            valueExtentColor: [Infinity, -Infinity],\n        },\n        facets: {},\n    };\n    const usedXKeys = new Set();\n    const usedYKeys = new Set();\n\n    const xLabelsSource = xColumn.valueLabels ?? xColumn.value;\n    const yLabelsSource = yColumn.valueLabels ?? yColumn.value;\n    data.rows.forEach(row => {\n        const facetKey = facetBy.length ? facetBy.map(column => row[column.value]).join('_') : 'null';\n        const x = row[xColumn.value] as string;\n        const y = row[yColumn.value] as string;\n        const sizeValue = (row[valueColumnSize.value] ?? NAValueAs) as (null | number);\n        const colorValue = (row[valueColumnColor.value] ?? NAValueAs) as (null | number);\n\n        if (x === null || y === null || sizeValue === null || colorValue === null) {\n            return;\n        }\n        if (!result.facets[facetKey]) {\n            result.facets[facetKey] = {\n                xKeys: [],\n                yKeys: [],\n                cells: {},\n            };\n        }\n        result.facets[facetKey].xKeys.push(x);\n        result.facets[facetKey].yKeys.push(y);\n\n        if (!usedXKeys.has(x)) {\n            usedXKeys.add(x);\n            result.meta.xKeys.push(x);\n        }\n        if (!usedYKeys.has(y)) {\n            usedYKeys.add(y);\n            result.meta.yKeys.push(y);\n        }\n        if (!result.facets[facetKey].cells[x]) {\n            result.facets[facetKey].cells[x] = {};\n        }\n        result.meta.valueExtentSize[0] = Math.min(sizeValue, result.meta.valueExtentSize[0]);\n        result.meta.valueExtentSize[1] = Math.max(sizeValue, result.meta.valueExtentSize[1]);\n        result.meta.valueExtentColor[0] = Math.min(colorValue, result.meta.valueExtentColor[0]);\n        result.meta.valueExtentColor[1] = Math.max(colorValue, result.meta.valueExtentColor[1]);\n\n        if (result.facets[facetKey].cells[x][y]) {\n            throw Error(`More than 1 value for x=${x}, y=${y}`);\n        }\n        if (result.meta.xLabels[x] && String(row[xLabelsSource]) !== result.meta.xLabels[x]) {\n            throw Error(`More than 1 x-label value for x=${x}`);\n        }\n        if (result.meta.yLabels[y] && String(row[yLabelsSource]) !== result.meta.yLabels[y]) {\n            throw Error(`More than 1 y-label value for y=${y}`);\n        }\n        result.meta.xLabels[x] = String(row[xLabelsSource]);\n        result.meta.yLabels[y] = String(row[yLabelsSource]);\n        if (result.meta)\n            result.facets[facetKey].cells[x][y] = {\n                id: `${x}_${y}`,\n                x,\n                y,\n                sizeValue,\n                normalizedSizeValue: sizeValue,\n                colorValue,\n                normalizedColorValue: colorValue,\n                data: row,\n            };\n    });\n    result.meta.facetKeys = result.meta.facetKeys.filter((key) => result.facets[key]); // filter only used;\n\n    // make uniq x, y, x-group and y-group keys\n    result.meta.facetKeys.forEach(facetKey => {\n        const facet = result.facets[facetKey];\n        facet.xKeys = lodash.uniq(facet.xKeys);\n        facet.yKeys = lodash.uniq(facet.yKeys);\n\n        if (facet.xKeys.length * facet.yKeys.length > MAX_RENDERED_CELLS_COUNT) {\n            throw Error(`Too many cells for graph rendering (${facet.xKeys.length * facet.yKeys.length})`);\n        }\n    });\n\n    if (normalization) {\n        //const valueExtentSize = [Infinity, -Infinity] as [number, number];\n        const valueExtentColor = [Infinity, -Infinity] as [number, number];\n        result.meta.facetKeys.forEach(facetKey => {\n            if (!result.facets[facetKey]) {\n                return;\n            }\n            const {xKeys, yKeys, cells} = result.facets[facetKey];\n            const cellKeys = normalization.direction === 'row' ? xKeys : yKeys;\n            const groupKeys = normalization.direction === 'row' ? yKeys : xKeys;\n            const cellGetter =\n                normalization.direction === 'row'\n                    ? (cellKey: string, groupKey: string) => cells[cellKey]?.[groupKey]\n                    : (cellKey: string, groupKey: string) => cells[groupKey]?.[cellKey];\n            groupKeys.forEach(groupKey => {\n                //const sizeValues:number[] = [];\n                const colorValues: number[] = [];\n                cellKeys.forEach(cellKey => {\n                    //const sizeV = cellGetter(cellKey, groupKey)?.sizeValue;\n                    const colorV = cellGetter(cellKey, groupKey)?.colorValue;\n                    // if (sizeV !== undefined) {\n                    //     sizeValues.push(sizeV as number);\n                    // }\n                    if (colorV !== undefined) {\n                        colorValues.push(colorV as number);\n                    }\n                });\n                // const normalizeSize = getNormalizationFn(normalization.method, sizeValues);\n                const normalizeColor = getNormalizationFn(normalization.method, colorValues);\n                cellKeys.forEach(cellKey => {\n                    const cell = cellGetter(cellKey, groupKey);\n                    if (cell !== undefined) {\n                        // cell.normalizedSizeValue = normalizeSize(cell.sizeValue as number);\n                        cell.normalizedColorValue = normalizeColor(cell.colorValue as number);\n                        // valueExtentSize[0] = Math.min(cell.normalizedSizeValue, valueExtentSize[0]);\n                        // valueExtentSize[1] = Math.max(cell.normalizedSizeValue, valueExtentSize[1]);\n                        valueExtentColor[0] = Math.min(cell.normalizedColorValue, valueExtentColor[0]);\n                        valueExtentColor[1] = Math.max(cell.normalizedColorValue, valueExtentColor[1]);\n                    }\n                });\n            });\n        });\n        // result.meta.valueExtentSize = valueExtentSize;\n        result.meta.valueExtentColor = valueExtentColor;\n    }\n\n    // avoid render errors on empty data\n    if (result.meta.valueExtentSize[0] === Infinity) {\n        result.meta.valueExtentSize[0] = 0;\n    }\n    if (result.meta.valueExtentSize[1] === -Infinity) {\n        result.meta.valueExtentSize[1] = 0;\n    }\n    if (result.meta.valueExtentColor[0] === Infinity) {\n        result.meta.valueExtentColor[0] = 0;\n    }\n    if (result.meta.valueExtentColor[1] === -Infinity) {\n        result.meta.valueExtentColor[1] = 0;\n    }\n\n    return result;\n}\n"],"names":["MAX_RENDERED_CELLS_COUNT","normalizeByStd","values","stdValue","deviation","meanValue","mean","v","normalizeByMinMax","min","max","extent","getNormalizationFn","method","getCells","data","xColumn","yColumn","valueColumnSize","valueColumnColor","facetBy","facetKeysCombinations","normalization","NAValueAs","facetKeys","result","res","key","index","usedXKeys","usedYKeys","xLabelsSource","yLabelsSource","row","facetKey","column","x","y","sizeValue","colorValue","facet","lodash","valueExtentColor","xKeys","yKeys","cells","cellKeys","groupKeys","cellGetter","cellKey","groupKey","_a","colorValues","colorV","normalizeColor","cell"],"mappings":";;;;AAMA,MAAMA,IAA2B;AACjC,SAASC,EAAeC,GAAkB;AACtC,QAAMC,IAAWC,EAAUF,CAAM,GAC3BG,IAAYC,EAAKJ,CAAM;AAE7B,SAAIC,MAAa,UAAaE,MAAc,UAAaF,MAAa,IAC3D,CAACI,MAAcA,IAEnB,CAACA,OAAeA,IAAIF,KAAaF;AAC5C;AAEA,SAASK,EAAkBN,GAAkB;AACzC,QAAMG,IAAYC,EAAKJ,CAAM,GACvB,CAACO,GAAKC,CAAG,IAAIC,EAAOT,CAAM;AAChC,SAAIG,MAAc,UAAaI,MAAQ,UAAaC,MAAQ,SACjD,CAAC,MAAc,IAEnB,CAAC,OAAe,IAAIL,MAAcK,IAAMD;AACnD;AAEA,SAASG,EAAmBC,GAA6BX,GAAkB;AACvE,SAAIW,MAAW,oBACJZ,EAAeC,CAAM,IAE5BW,MAAW,sBACJL,EAAkBN,CAAM,IAE5B,CAACK,MAAcA;AAC1B;AAqCO,SAASO,EACZC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACgB;AAChB,QAAMC,IAAYH,EAAsB,IAAI,OAAKd,EAAE,KAAK,GAAG,CAAC,GACtDkB,IAA2B;AAAA,IAC7B,MAAM;AAAA,MACF,WAAAD;AAAA,MACA,OAAO,CAAA;AAAA,MACP,OAAO,CAAA;AAAA,MACP,SAAS,CAAA;AAAA,MACT,SAAS,CAAA;AAAA,MACT,gBAAgBA,EAAU,OAAO,CAACE,GAA+BC,GAAKC,OAClEF,EAAIC,CAAG,IAAIN,EAAsBO,CAAK,GAC/BF,IACR,CAAA,CAAE;AAAA,MACL,iBAAiB,CAAC,OAAU,MAAS;AAAA,MACrC,kBAAkB,CAAC,OAAU,MAAS;AAAA,IAAA;AAAA,IAE1C,QAAQ,CAAA;AAAA,EAAC,GAEPG,wBAAgB,IAAA,GAChBC,wBAAgB,IAAA,GAEhBC,IAAgBf,EAAQ,eAAeA,EAAQ,OAC/CgB,IAAgBf,EAAQ,eAAeA,EAAQ;AAyErD,MAxEAF,EAAK,KAAK,QAAQ,CAAAkB,MAAO;AACrB,UAAMC,IAAWd,EAAQ,SAASA,EAAQ,IAAI,CAAAe,MAAUF,EAAIE,EAAO,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,QACjFC,IAAIH,EAAIjB,EAAQ,KAAK,GACrBqB,IAAIJ,EAAIhB,EAAQ,KAAK,GACrBqB,IAAaL,EAAIf,EAAgB,KAAK,KAAKK,GAC3CgB,IAAcN,EAAId,EAAiB,KAAK,KAAKI;AAEnD,QAAI,EAAAa,MAAM,QAAQC,MAAM,QAAQC,MAAc,QAAQC,MAAe,OA6BrE;AAAA,UA1BKd,EAAO,OAAOS,CAAQ,MACvBT,EAAO,OAAOS,CAAQ,IAAI;AAAA,QACtB,OAAO,CAAA;AAAA,QACP,OAAO,CAAA;AAAA,QACP,OAAO,CAAA;AAAA,MAAC,IAGhBT,EAAO,OAAOS,CAAQ,EAAE,MAAM,KAAKE,CAAC,GACpCX,EAAO,OAAOS,CAAQ,EAAE,MAAM,KAAKG,CAAC,GAE/BR,EAAU,IAAIO,CAAC,MAChBP,EAAU,IAAIO,CAAC,GACfX,EAAO,KAAK,MAAM,KAAKW,CAAC,IAEvBN,EAAU,IAAIO,CAAC,MAChBP,EAAU,IAAIO,CAAC,GACfZ,EAAO,KAAK,MAAM,KAAKY,CAAC,IAEvBZ,EAAO,OAAOS,CAAQ,EAAE,MAAME,CAAC,MAChCX,EAAO,OAAOS,CAAQ,EAAE,MAAME,CAAC,IAAI,CAAA,IAEvCX,EAAO,KAAK,gBAAgB,CAAC,IAAI,KAAK,IAAIa,GAAWb,EAAO,KAAK,gBAAgB,CAAC,CAAC,GACnFA,EAAO,KAAK,gBAAgB,CAAC,IAAI,KAAK,IAAIa,GAAWb,EAAO,KAAK,gBAAgB,CAAC,CAAC,GACnFA,EAAO,KAAK,iBAAiB,CAAC,IAAI,KAAK,IAAIc,GAAYd,EAAO,KAAK,iBAAiB,CAAC,CAAC,GACtFA,EAAO,KAAK,iBAAiB,CAAC,IAAI,KAAK,IAAIc,GAAYd,EAAO,KAAK,iBAAiB,CAAC,CAAC,GAElFA,EAAO,OAAOS,CAAQ,EAAE,MAAME,CAAC,EAAEC,CAAC;AAClC,cAAM,MAAM,2BAA2BD,CAAC,OAAOC,CAAC,EAAE;AAEtD,UAAIZ,EAAO,KAAK,QAAQW,CAAC,KAAK,OAAOH,EAAIF,CAAa,CAAC,MAAMN,EAAO,KAAK,QAAQW,CAAC;AAC9E,cAAM,MAAM,mCAAmCA,CAAC,EAAE;AAEtD,UAAIX,EAAO,KAAK,QAAQY,CAAC,KAAK,OAAOJ,EAAID,CAAa,CAAC,MAAMP,EAAO,KAAK,QAAQY,CAAC;AAC9E,cAAM,MAAM,mCAAmCA,CAAC,EAAE;AAEtD,MAAAZ,EAAO,KAAK,QAAQW,CAAC,IAAI,OAAOH,EAAIF,CAAa,CAAC,GAClDN,EAAO,KAAK,QAAQY,CAAC,IAAI,OAAOJ,EAAID,CAAa,CAAC,GAC9CP,EAAO,SACPA,EAAO,OAAOS,CAAQ,EAAE,MAAME,CAAC,EAAEC,CAAC,IAAI;AAAA,QAClC,IAAI,GAAGD,CAAC,IAAIC,CAAC;AAAA,QACb,GAAAD;AAAA,QACA,GAAAC;AAAA,QACA,WAAAC;AAAA,QACA,qBAAqBA;AAAA,QACrB,YAAAC;AAAA,QACA,sBAAsBA;AAAA,QACtB,MAAMN;AAAA,MAAA;AAAA;AAAA,EAElB,CAAC,GACDR,EAAO,KAAK,YAAYA,EAAO,KAAK,UAAU,OAAO,CAACE,MAAQF,EAAO,OAAOE,CAAG,CAAC,GAGhFF,EAAO,KAAK,UAAU,QAAQ,CAAAS,MAAY;AACtC,UAAMM,IAAQf,EAAO,OAAOS,CAAQ;AAIpC,QAHAM,EAAM,QAAQC,EAAO,KAAKD,EAAM,KAAK,GACrCA,EAAM,QAAQC,EAAO,KAAKD,EAAM,KAAK,GAEjCA,EAAM,MAAM,SAASA,EAAM,MAAM,SAASxC;AAC1C,YAAM,MAAM,uCAAuCwC,EAAM,MAAM,SAASA,EAAM,MAAM,MAAM,GAAG;AAAA,EAErG,CAAC,GAEGlB,GAAe;AAEf,UAAMoB,IAAmB,CAAC,OAAU,MAAS;AAC7C,IAAAjB,EAAO,KAAK,UAAU,QAAQ,CAAAS,MAAY;AACtC,UAAI,CAACT,EAAO,OAAOS,CAAQ;AACvB;AAEJ,YAAM,EAAC,OAAAS,GAAO,OAAAC,GAAO,OAAAC,MAASpB,EAAO,OAAOS,CAAQ,GAC9CY,IAAWxB,EAAc,cAAc,QAAQqB,IAAQC,GACvDG,IAAYzB,EAAc,cAAc,QAAQsB,IAAQD,GACxDK,IACF1B,EAAc,cAAc,QACtB,CAAC2B,GAAiBC;;AAAqB,gBAAAC,IAAAN,EAAMI,CAAO,MAAb,gBAAAE,EAAiBD;AAAA,UACxD,CAACD,GAAiBC;;AAAqB,gBAAAC,IAAAN,EAAMK,CAAQ,MAAd,gBAAAC,EAAkBF;AAAA;AACnE,MAAAF,EAAU,QAAQ,CAAAG,MAAY;AAE1B,cAAME,IAAwB,CAAA;AAC9B,QAAAN,EAAS,QAAQ,CAAAG,MAAW;;AAExB,gBAAMI,KAASF,IAAAH,EAAWC,GAASC,CAAQ,MAA5B,gBAAAC,EAA+B;AAI9C,UAAIE,MAAW,UACXD,EAAY,KAAKC,CAAgB;AAAA,QAEzC,CAAC;AAED,cAAMC,IAAiB1C,EAAmBU,EAAc,QAAQ8B,CAAW;AAC3E,QAAAN,EAAS,QAAQ,CAAAG,MAAW;AACxB,gBAAMM,IAAOP,EAAWC,GAASC,CAAQ;AACzC,UAAIK,MAAS,WAETA,EAAK,uBAAuBD,EAAeC,EAAK,UAAoB,GAGpEb,EAAiB,CAAC,IAAI,KAAK,IAAIa,EAAK,sBAAsBb,EAAiB,CAAC,CAAC,GAC7EA,EAAiB,CAAC,IAAI,KAAK,IAAIa,EAAK,sBAAsBb,EAAiB,CAAC,CAAC;AAAA,QAErF,CAAC;AAAA,MACL,CAAC;AAAA,IACL,CAAC,GAEDjB,EAAO,KAAK,mBAAmBiB;AAAA,EACnC;AAGA,SAAIjB,EAAO,KAAK,gBAAgB,CAAC,MAAM,UACnCA,EAAO,KAAK,gBAAgB,CAAC,IAAI,IAEjCA,EAAO,KAAK,gBAAgB,CAAC,MAAM,WACnCA,EAAO,KAAK,gBAAgB,CAAC,IAAI,IAEjCA,EAAO,KAAK,iBAAiB,CAAC,MAAM,UACpCA,EAAO,KAAK,iBAAiB,CAAC,IAAI,IAElCA,EAAO,KAAK,iBAAiB,CAAC,MAAM,WACpCA,EAAO,KAAK,iBAAiB,CAAC,IAAI,IAG/BA;AACX;"}

package/dist/node_modules/d3-quadtree/src/add.js

@@ -1,30 +0,0 @@
-function A(i) {
-  const f = +this._x.call(null, i), n = +this._y.call(null, i);
-  return v(this.cover(f, n), f, n, i);
-}
-function v(i, f, n, c) {
-  if (isNaN(f) || isNaN(n)) return i;
-  var l, t = i._root, r = { data: c }, y = i._x0, o = i._y0, s = i._x1, u = i._y1, a, _, e, N, x, d, h, w;
-  if (!t) return i._root = r, i;
-  for (; t.length; )
-    if ((x = f >= (a = (y + s) / 2)) ? y = a : s = a, (d = n >= (_ = (o + u) / 2)) ? o = _ : u = _, l = t, !(t = t[h = d << 1 | x])) return l[h] = r, i;
-  if (e = +i._x.call(null, t.data), N = +i._y.call(null, t.data), f === e && n === N) return r.next = t, l ? l[h] = r : i._root = r, i;
-  do
-    l = l ? l[h] = new Array(4) : i._root = new Array(4), (x = f >= (a = (y + s) / 2)) ? y = a : s = a, (d = n >= (_ = (o + u) / 2)) ? o = _ : u = _;
-  while ((h = d << 1 | x) === (w = (N >= _) << 1 | e >= a));
-  return l[w] = t, l[h] = r, i;
-}
-function p(i) {
-  var f, n, c = i.length, l, t, r = new Array(c), y = new Array(c), o = 1 / 0, s = 1 / 0, u = -1 / 0, a = -1 / 0;
-  for (n = 0; n < c; ++n)
-    isNaN(l = +this._x.call(null, f = i[n])) || isNaN(t = +this._y.call(null, f)) || (r[n] = l, y[n] = t, l < o && (o = l), l > u && (u = l), t < s && (s = t), t > a && (a = t));
-  if (o > u || s > a) return this;
-  for (this.cover(o, s).cover(u, a), n = 0; n < c; ++n)
-    v(this, r[n], y[n], i[n]);
-  return this;
-}
-export {
-  p as addAll,
-  A as default
-};
-//# sourceMappingURL=add.js.map

package/dist/node_modules/d3-quadtree/src/add.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"add.js","sources":["../../../../node_modules/d3-quadtree/src/add.js"],"sourcesContent":["export default function(d) {\n  const x = +this._x.call(null, d),\n      y = +this._y.call(null, d);\n  return add(this.cover(x, y), x, y, d);\n}\n\nfunction add(tree, x, y, d) {\n  if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points\n\n  var parent,\n      node = tree._root,\n      leaf = {data: d},\n      x0 = tree._x0,\n      y0 = tree._y0,\n      x1 = tree._x1,\n      y1 = tree._y1,\n      xm,\n      ym,\n      xp,\n      yp,\n      right,\n      bottom,\n      i,\n      j;\n\n  // If the tree is empty, initialize the root as a leaf.\n  if (!node) return tree._root = leaf, tree;\n\n  // Find the existing leaf for the new point, or add it.\n  while (node.length) {\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n    if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;\n  }\n\n  // Is the new point is exactly coincident with the existing point?\n  xp = +tree._x.call(null, node.data);\n  yp = +tree._y.call(null, node.data);\n  if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;\n\n  // Otherwise, split the leaf node until the old and new point are separated.\n  do {\n    parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);\n    if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm;\n    if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym;\n  } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm)));\n  return parent[j] = node, parent[i] = leaf, tree;\n}\n\nexport function addAll(data) {\n  var d, i, n = data.length,\n      x,\n      y,\n      xz = new Array(n),\n      yz = new Array(n),\n      x0 = Infinity,\n      y0 = Infinity,\n      x1 = -Infinity,\n      y1 = -Infinity;\n\n  // Compute the points and their extent.\n  for (i = 0; i < n; ++i) {\n    if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue;\n    xz[i] = x;\n    yz[i] = y;\n    if (x < x0) x0 = x;\n    if (x > x1) x1 = x;\n    if (y < y0) y0 = y;\n    if (y > y1) y1 = y;\n  }\n\n  // If there were no (valid) points, abort.\n  if (x0 > x1 || y0 > y1) return this;\n\n  // Expand the tree to cover the new points.\n  this.cover(x0, y0).cover(x1, y1);\n\n  // Add the new points.\n  for (i = 0; i < n; ++i) {\n    add(this, xz[i], yz[i], data[i]);\n  }\n\n  return this;\n}\n"],"names":["tree_add","d","x","y","add","tree","parent","node","leaf","x0","y0","x1","y1","xm","ym","xp","yp","right","bottom","i","j","addAll","data","n","xz","yz"],"mappings":"AAAe,SAAAA,EAASC,GAAG;AACzB,QAAMC,IAAI,CAAC,KAAK,GAAG,KAAK,MAAMD,CAAC,GAC3BE,IAAI,CAAC,KAAK,GAAG,KAAK,MAAMF,CAAC;AAC7B,SAAOG,EAAI,KAAK,MAAMF,GAAGC,CAAC,GAAGD,GAAGC,GAAGF,CAAC;AACtC;AAEA,SAASG,EAAIC,GAAMH,GAAGC,GAAGF,GAAG;AAC1B,MAAI,MAAMC,CAAC,KAAK,MAAMC,CAAC,EAAG,QAAOE;AAEjC,MAAIC,GACAC,IAAOF,EAAK,OACZG,IAAO,EAAC,MAAMP,EAAC,GACfQ,IAAKJ,EAAK,KACVK,IAAKL,EAAK,KACVM,IAAKN,EAAK,KACVO,IAAKP,EAAK,KACVQ,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC;AAGJ,MAAI,CAACb,EAAM,QAAOF,EAAK,QAAQG,GAAMH;AAGrC,SAAOE,EAAK;AAGV,SAFIU,IAAQf,MAAMW,KAAMJ,IAAKE,KAAM,MAAIF,IAAKI,IAASF,IAAKE,IACtDK,IAASf,MAAMW,KAAMJ,IAAKE,KAAM,MAAIF,IAAKI,IAASF,IAAKE,GACvDR,IAASC,GAAM,EAAEA,IAAOA,EAAKY,IAAID,KAAU,IAAID,CAAK,GAAI,QAAOX,EAAOa,CAAC,IAAIX,GAAMH;AAMvF,MAFAU,IAAK,CAACV,EAAK,GAAG,KAAK,MAAME,EAAK,IAAI,GAClCS,IAAK,CAACX,EAAK,GAAG,KAAK,MAAME,EAAK,IAAI,GAC9BL,MAAMa,KAAMZ,MAAMa,EAAI,QAAOR,EAAK,OAAOD,GAAMD,IAASA,EAAOa,CAAC,IAAIX,IAAOH,EAAK,QAAQG,GAAMH;AAGlG;AACE,IAAAC,IAASA,IAASA,EAAOa,CAAC,IAAI,IAAI,MAAM,CAAC,IAAId,EAAK,QAAQ,IAAI,MAAM,CAAC,IACjEY,IAAQf,MAAMW,KAAMJ,IAAKE,KAAM,MAAIF,IAAKI,IAASF,IAAKE,IACtDK,IAASf,MAAMW,KAAMJ,IAAKE,KAAM,MAAIF,IAAKI,IAASF,IAAKE;AAAA,UACnDK,IAAID,KAAU,IAAID,QAAYG,KAAKJ,KAAMF,MAAO,IAAKC,KAAMF;AACrE,SAAOP,EAAOc,CAAC,IAAIb,GAAMD,EAAOa,CAAC,IAAIX,GAAMH;AAC7C;AAEO,SAASgB,EAAOC,GAAM;AAC3B,MAAIrB,GAAGkB,GAAGI,IAAID,EAAK,QACfpB,GACAC,GACAqB,IAAK,IAAI,MAAMD,CAAC,GAChBE,IAAK,IAAI,MAAMF,CAAC,GAChBd,IAAK,OACLC,IAAK,OACLC,IAAK,QACLC,IAAK;AAGT,OAAKO,IAAI,GAAGA,IAAII,GAAG,EAAEJ;AACnB,IAAI,MAAMjB,IAAI,CAAC,KAAK,GAAG,KAAK,MAAMD,IAAIqB,EAAKH,CAAC,CAAC,CAAC,KAAK,MAAMhB,IAAI,CAAC,KAAK,GAAG,KAAK,MAAMF,CAAC,CAAC,MACnFuB,EAAGL,CAAC,IAAIjB,GACRuB,EAAGN,CAAC,IAAIhB,GACJD,IAAIO,MAAIA,IAAKP,IACbA,IAAIS,MAAIA,IAAKT,IACbC,IAAIO,MAAIA,IAAKP,IACbA,IAAIS,MAAIA,IAAKT;AAInB,MAAIM,IAAKE,KAAMD,IAAKE,EAAI,QAAO;AAM/B,OAHA,KAAK,MAAMH,GAAIC,CAAE,EAAE,MAAMC,GAAIC,CAAE,GAG1BO,IAAI,GAAGA,IAAII,GAAG,EAAEJ;AACnB,IAAAf,EAAI,MAAMoB,EAAGL,CAAC,GAAGM,EAAGN,CAAC,GAAGG,EAAKH,CAAC,CAAC;AAGjC,SAAO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/d3-quadtree/src/cover.js

@@ -1,29 +0,0 @@
-function f(a, e) {
-  if (isNaN(a = +a) || isNaN(e = +e)) return this;
-  var t = this._x0, i = this._y0, h = this._x1, r = this._y1;
-  if (isNaN(t))
-    h = (t = Math.floor(a)) + 1, r = (i = Math.floor(e)) + 1;
-  else {
-    for (var s = h - t || 1, o = this._root, _, c; t > a || a >= h || i > e || e >= r; )
-      switch (c = (e < i) << 1 | a < t, _ = new Array(4), _[c] = o, o = _, s *= 2, c) {
-        case 0:
-          h = t + s, r = i + s;
-          break;
-        case 1:
-          t = h - s, r = i + s;
-          break;
-        case 2:
-          h = t + s, i = r - s;
-          break;
-        case 3:
-          t = h - s, i = r - s;
-          break;
-      }
-    this._root && this._root.length && (this._root = o);
-  }
-  return this._x0 = t, this._y0 = i, this._x1 = h, this._y1 = r, this;
-}
-export {
-  f as default
-};
-//# sourceMappingURL=cover.js.map