@milaboratories/miplots4 1.0.122 → 1.0.124

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

@@ -0,0 +1 @@
+{"version":3,"file":"scatterplot.d.ts","sourceRoot":"","sources":["../../src/types/scatterplot.ts"],"names":[],"mappings":"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"}

package/dist/types/scatterplot.js

@@ -0,0 +1,85 @@
+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";
+const e = o.object({
+  type: o.literal("grouping"),
+  value: o.string(),
+  // link to aes mapped to column
+  palette: o.optional(o.array(o.string()))
+  // if defined we use palette to create mapping without inheritedAes field
+}), m = o.object({
+  type: o.literal("dots"),
+  aes: o.optional(
+    o.object({
+      dotFill: o.optional(o.union([o.string(), e, n(o.string())])),
+      dotShape: o.optional(o.union([i, e])),
+      dotSize: o.optional(o.union([o.number(), n(o.number())]))
+    })
+  )
+}), h = o.object({
+  type: o.literal("curve"),
+  smoothing: o.optional(o.boolean()),
+  aes: o.optional(
+    o.object({
+      lineWidth: o.optional(o.number()),
+      lineShape: o.optional(l),
+      lineColor: o.optional(o.union([o.string(), e, n(o.string())])),
+      opacity: o.optional(o.number())
+    })
+  )
+}), b = o.union([m, h]), S = o.object({
+  type: o.literal("scatterplot"),
+  title: o.object({
+    name: o.string(),
+    show: o.optional(o.boolean()),
+    position: o.optional(c)
+  }),
+  size: o.optional(
+    o.object({
+      width: o.optional(o.number()),
+      height: o.optional(o.number())
+    })
+  ),
+  legend: o.optional(
+    o.object({
+      show: o.optional(o.boolean()),
+      position: o.optional(s)
+    })
+  ),
+  tooltips: o.optional(
+    o.object({
+      show: o.optional(o.boolean()),
+      content: o.optional(o.array(t))
+    })
+  ),
+  frame: o.optional(o.object({ type: o.optional(r) })),
+  facetSettings: o.optional(
+    o.object({
+      sharedX: o.optional(o.boolean()),
+      sharedY: o.optional(o.boolean()),
+      nRows: o.optional(o.number()),
+      nCols: o.optional(o.number())
+    })
+  ),
+  keyColumn: t,
+  x: t,
+  y: t,
+  xAxis: o.optional(a),
+  yAxis: o.optional(a),
+  grouping: o.optional(o.array(t)),
+  facetBy: o.optional(o.array(t)),
+  label: o.optional(t),
+  highlight: o.optional(t),
+  inheritedAes: o.optional(o.record(o.string(), p)),
+  trend: o.optional(
+    o.object({
+      color: o.optional(o.optional(o.union([o.string(), e, n(o.string())]))),
+      bounded: o.optional(o.boolean())
+      // if true: line and area bounded with min and max X value; else line bounded by chart bounds
+    })
+  ),
+  layers: o.array(b)
+});
+export {
+  S as ScatterplotSettingsSchema
+};
+//# sourceMappingURL=scatterplot.js.map

package/dist/types/scatterplot.js.map

@@ -0,0 +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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"}

package/dist/utils/TextMeasurer.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextMeasurer.d.ts","sourceRoot":"","sources":["../../src/utils/TextMeasurer.tsx"],"names":[],"mappings":"AAGA,qBAAa,YAAY;IACrB,GAAG,EAAE,wBAAwB,GAAG,IAAI,CAAQ;gBAChC,IAAI,SAAiB;IAcjC,IAAI,IAAI,CAAC,IAAI,EAAE,MAAM,EAIpB;IAED,cAAc,CAAC,IAAI,EAAE,MAAM,GAAE,WAAW,GAAG,IAAI;IAO/C,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAMrC"}

package/dist/utils/TextMeasurer.js

@@ -0,0 +1,27 @@
+var r = Object.defineProperty;
+var i = (c, t, e) => t in c ? r(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e;
+var s = (c, t, e) => i(c, typeof t != "symbol" ? t + "" : t, e);
+class h {
+  constructor(t = "14px Manrope") {
+    s(this, "ctx", null);
+    if (document) {
+      const e = document == null ? void 0 : document.createElement("canvas");
+      e.width = 500, e.height = 30;
+      const n = e.getContext("2d");
+      n && (n.font = t, this.ctx = n);
+    }
+  }
+  set font(t) {
+    this.ctx && (this.ctx.font = t);
+  }
+  getTextMetrics(t) {
+    return this.ctx ? this.ctx.measureText(t) : null;
+  }
+  getTextWidth(t) {
+    return this.ctx ? this.ctx.measureText(t).width : 0;
+  }
+}
+export {
+  h as TextMeasurer
+};
+//# sourceMappingURL=TextMeasurer.js.map

package/dist/utils/TextMeasurer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextMeasurer.js","sources":["../../src/utils/TextMeasurer.tsx"],"sourcesContent":["// import type {Canvas, CanvasRenderingContext2D} from 'canvas';\n// import {createCanvas} from 'canvas';\n// node-canvas https://github.com/Automattic/node-canvas has problems with building for windows\nexport class TextMeasurer {\n    ctx: CanvasRenderingContext2D | null = null;\n    constructor(font = '14px Manrope') {\n        // const canvas: Canvas = createCanvas(500, 30);\n        // const ctx = canvas.getContext('2d');\n        if (document) {\n            const canvas = document?.createElement('canvas');//createCanvas(500, 30);\n            canvas.width = 500;\n            canvas.height = 30;\n            const ctx = canvas.getContext('2d');\n            if (ctx) {\n                ctx.font = font;\n                this.ctx = ctx;\n            }\n        }\n    }\n    set font(font: string) {\n        if (this.ctx) {\n            this.ctx.font = font;\n        }\n    }\n\n    getTextMetrics(text: string):TextMetrics | null {\n        if (!this.ctx) {\n            return null;\n        }\n        return this.ctx.measureText(text);\n    }\n\n    getTextWidth(text: string): number {\n        if (!this.ctx) {\n            return 0;\n        }\n        return this.ctx.measureText(text).width;\n    }\n}\n"],"names":["TextMeasurer","font","__publicField","canvas","ctx","text"],"mappings":";;;AAGO,MAAMA,EAAa;AAAA,EAEtB,YAAYC,IAAO,gBAAgB;AADnC,IAAAC,EAAA,aAAuC;AAInC,QAAI,UAAU;AACV,YAAMC,IAAS,qCAAU,cAAc;AACvC,MAAAA,EAAO,QAAQ,KACfA,EAAO,SAAS;AAChB,YAAMC,IAAMD,EAAO,WAAW,IAAI;AAClC,MAAIC,MACAA,EAAI,OAAOH,GACX,KAAK,MAAMG;AAAA,IAEnB;AAAA,EACJ;AAAA,EACA,IAAI,KAAKH,GAAc;AACnB,IAAI,KAAK,QACL,KAAK,IAAI,OAAOA;AAAA,EAExB;AAAA,EAEA,eAAeI,GAAiC;AAC5C,WAAK,KAAK,MAGH,KAAK,IAAI,YAAYA,CAAI,IAFrB;AAAA,EAGf;AAAA,EAEA,aAAaA,GAAsB;AAC/B,WAAK,KAAK,MAGH,KAAK,IAAI,YAAYA,CAAI,EAAE,QAFvB;AAAA,EAGf;AACJ;"}

package/dist/utils/arrangeLegendParts.d.ts

@@ -0,0 +1,3 @@
+import { LegendItem } from '../common/types';
+export declare function arrangeLegendParts(legendItems: LegendItem[], maxHeight: number, continuousHeight?: number): LegendItem[];
+//# sourceMappingURL=arrangeLegendParts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrangeLegendParts.d.ts","sourceRoot":"","sources":["../../src/utils/arrangeLegendParts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAoClD,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,SAAS,EAAC,MAAM,EAAE,gBAAgB,CAAC,EAAC,MAAM,GAAE,UAAU,EAAE,CAuHrH"}

package/dist/utils/arrangeLegendParts.js

@@ -0,0 +1,49 @@
+import { TextMeasurer as U } from "./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) {
+  return Math.max(
+    ...a.map((h) => O.getTextWidth(String(h)) + A),
+    O.getTextWidth(o)
+  );
+}
+function B(a, o, h, d) {
+  const t = [[]];
+  let e = 0, n = o, i = 0;
+  return a.forEach((s) => {
+    e + d <= n ? (t[i].push(s), e += d) : (t.push([s]), i++, e = d, n = h);
+  }), t;
+}
+function X(a, o, h) {
+  const d = h ?? o;
+  let t = 0, e = 0, n = 0;
+  a.sort((s, l) => s.type === "continuous" && l.type !== "continuous" ? -1 : l.type === "continuous" && s.type !== "continuous" ? 1 : s.type === "dots" && l.type !== "dots" ? -1 : l.type === "dots" && s.type !== "dots" ? 1 : 0);
+  const i = [];
+  return a.forEach((s) => {
+    const { type: l, values: T, title: E, id: v, scale: S } = s;
+    if (l === "continuous") {
+      const p = $(T, E), c = d;
+      o - e < c && (n += t + f, t = 0, e = 0);
+      const u = n, y = e;
+      p > t && (t = p), e += c + W, e >= o && (n += t + f, t = 0, e = 0), i.push({ ...s, width: p, height: c, left: u, top: y });
+    } else if (l === "size") {
+      const { labels: p } = s, c = S(Math.max(...T)) * 2 + 4, r = _(T.map((g) => p[g]), E), u = T.length * c;
+      o - e < u && (n += t + f, t = 0, e = 0);
+      const L = n, I = e;
+      r > t && (t = r), e += u + W, e >= o && (n += t + f, t = 0, e = 0), i.push({ ...s, width: r, height: u, left: L, top: I });
+    } else {
+      const { labels: p } = s, c = z;
+      let r = o - e;
+      r < c && (r = o, n += t + f, t = 0, e = 0);
+      const u = B(T, r, o, c), y = _([], E), L = t === 0, I = n + y + f;
+      u.forEach((g, R) => {
+        const F = R === u.length - 1, C = R > 0 ? "" : E, b = R > 0 ? `${v}_${R}` : v, M = _(g.map((P) => p[P]), L && !F ? "" : C), w = g.length * c, G = n, N = e;
+        M > t && (t = M), F ? e += w + W : e = o, e >= o && (n += t + f, L && F && n < I && (n = I), t = 0, e = 0), i.push({ ...s, id: b, title: C, width: M, height: w, left: G, top: N, values: g });
+      });
+    }
+  }), i;
+}
+export {
+  X as arrangeLegendParts
+};
+//# sourceMappingURL=arrangeLegendParts.js.map

package/dist/utils/arrangeLegendParts.js.map

@@ -0,0 +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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"}

package/dist/utils/getChartEdgeSides.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getChartEdgeSides.d.ts","sourceRoot":"","sources":["../../src/utils/getChartEdgeSides.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,2CAmB5G"}

package/dist/utils/getChartEdgeSides.js

@@ -0,0 +1,8 @@
+function r(f, i, h, t) {
+  const p = [];
+  return f % h === h - 1 && p.push("right"), f % h === 0 && p.push("left"), f < h && p.push("top"), (Math.ceil((f + 1) / h) === t || Math.ceil((f + 1) / h) === t - 1 && f % h > (i - 1) % h) && p.push("bottom"), p;
+}
+export {
+  r as getChartEdgeSides
+};
+//# sourceMappingURL=getChartEdgeSides.js.map

package/dist/utils/getChartEdgeSides.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getChartEdgeSides.js","sources":["../../src/utils/getChartEdgeSides.ts"],"sourcesContent":["export function getChartEdgeSides(index: number, facetsCount: number, columnsCount: number, rowsCount: number) {\n    const chartSides: ('left' | 'right' | 'top' | 'bottom')[] = [];\n    if (index % columnsCount === columnsCount - 1) {\n        chartSides.push('right');\n    }\n    if (index % columnsCount === 0) {\n        chartSides.push('left');\n    }\n    if (index < columnsCount) {\n        chartSides.push('top');\n    }\n    if (\n        Math.ceil((index + 1) / columnsCount) === rowsCount ||\n        (Math.ceil((index + 1) / columnsCount) === rowsCount - 1 &&\n            index % columnsCount > (facetsCount - 1) % columnsCount)\n    ) {\n        chartSides.push('bottom');\n    }\n    return chartSides;\n}\n"],"names":["getChartEdgeSides","index","facetsCount","columnsCount","rowsCount","chartSides"],"mappings":"AAAO,SAASA,EAAkBC,GAAeC,GAAqBC,GAAsBC,GAAmB;AAC3G,QAAMC,IAAsD,CAAA;AAC5D,SAAIJ,IAAQE,MAAiBA,IAAe,KACxCE,EAAW,KAAK,OAAO,GAEvBJ,IAAQE,MAAiB,KACzBE,EAAW,KAAK,MAAM,GAEtBJ,IAAQE,KACRE,EAAW,KAAK,KAAK,IAGrB,KAAK,MAAMJ,IAAQ,KAAKE,CAAY,MAAMC,KACzC,KAAK,MAAMH,IAAQ,KAAKE,CAAY,MAAMC,IAAY,KACnDH,IAAQE,KAAgBD,IAAc,KAAKC,MAE/CE,EAAW,KAAK,QAAQ,GAErBA;AACX;"}

package/dist/utils/getContinuousColorScale.d.ts

@@ -0,0 +1,2 @@
+export declare function getContinuousColorScale(colors: string[], valueExtent: number[], type: 'log' | 'linear'): import('d3-scale').ScaleLinear<string, string, never> | import('d3-scale').ScaleSymLog<string, string, never>;
+//# sourceMappingURL=getContinuousColorScale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getContinuousColorScale.d.ts","sourceRoot":"","sources":["../../src/utils/getContinuousColorScale.ts"],"names":[],"mappings":"AAsCA,wBAAgB,uBAAuB,CAAC,MAAM,EAAC,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,QAAQ,iHAKrG"}

package/dist/utils/getContinuousColorScale.js

@@ -0,0 +1,33 @@
+import p from "../node_modules/d3-scale/src/linear.js";
+import g from "../node_modules/d3-scale/src/symlog.js";
+const f = (o, n) => {
+  const r = Math.min(...n), i = Math.max(...n);
+  if (r === i) {
+    const s = o % 2 === 0 ? [] : [r];
+    for (let e = 1; e < o / 2 + 1; e++)
+      s.push(r + e), s.unshift(r - e);
+    return s;
+  }
+  if (o < 2)
+    return [r, i];
+  const m = (i - r) / (o - 1), t = [];
+  for (let s = 0; s < o - 1; s++)
+    t.push(r + m * s);
+  return t.push(i), t;
+};
+function a(o, n, r) {
+  if (r === "linear")
+    return f(o, n);
+  if (r === "log") {
+    const i = f(o, n), m = g(n, n), t = i.map((s) => m.invert(s));
+    return t[0] = n[0], t[t.length - 1] = n[1], t;
+  }
+  return [];
+}
+function h(o, n, r) {
+  return (r === "log" ? g() : p()).domain(a(o.length, n, r)).range(o);
+}
+export {
+  h as getContinuousColorScale
+};
+//# sourceMappingURL=getContinuousColorScale.js.map

package/dist/utils/getContinuousColorScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getContinuousColorScale.js","sources":["../../src/utils/getContinuousColorScale.ts"],"sourcesContent":["import {scaleLinear, scaleSymlog} from 'd3-scale';\n\nconst getSteps = (count: number, valueExtent: number[]) => {\n    const min = Math.min(...valueExtent);\n    const max = Math.max(...valueExtent);\n    if (min === max) {\n        const steps = count % 2 === 0 ? [] : [min];\n        for (let i = 1; i < count / 2 + 1; i++) {\n            steps.push(min + i);\n            steps.unshift(min - i);\n        }\n        return steps;\n    }\n    if (count < 2) {\n        return [min, max];\n    }\n    const step = (max - min) / (count - 1);\n    const steps = [];\n    for (let i = 0; i < count - 1; i++) {\n        steps.push(min + step * i);\n    }\n    steps.push(max);\n    return steps;\n};\nfunction getColorScaleDomain(count: number, valueExtent: number[], type: 'log' | 'linear'):number[] {\n    if (type === 'linear') {\n        return getSteps(count, valueExtent);\n    }\n    if (type === 'log') {\n        const linearSteps = getSteps(count, valueExtent); // to have number values exactly opposite color values\n        const transformLogScale = scaleSymlog(valueExtent, valueExtent);\n        const logSteps = linearSteps.map((v) => transformLogScale.invert(v));\n        logSteps[0] = valueExtent[0];\n        logSteps[logSteps.length - 1] = valueExtent[1];\n        return logSteps;\n    }\n    return [];\n}\nexport function getContinuousColorScale(colors:string[], valueExtent: number[], type: 'log' | 'linear') {\n    return (type === 'log' ? scaleSymlog<string, string>() : scaleLinear<string, string>())\n        .domain(getColorScaleDomain(colors.length, valueExtent, type))\n        // @ts-ignore\n        .range(colors);\n}"],"names":["getSteps","count","valueExtent","min","max","steps","i","step","getColorScaleDomain","type","linearSteps","transformLogScale","scaleSymlog","logSteps","v","getContinuousColorScale","colors","scaleLinear"],"mappings":";;AAEA,MAAMA,IAAW,CAACC,GAAeC,MAA0B;AACvD,QAAMC,IAAM,KAAK,IAAI,GAAGD,CAAW,GAC7BE,IAAM,KAAK,IAAI,GAAGF,CAAW;AACnC,MAAIC,MAAQC,GAAK;AACb,UAAMC,IAAQJ,IAAQ,MAAM,IAAI,CAAA,IAAK,CAACE,CAAG;AACzC,aAASG,IAAI,GAAGA,IAAIL,IAAQ,IAAI,GAAGK;AAC/BD,MAAAA,EAAM,KAAKF,IAAMG,CAAC,GAClBD,EAAM,QAAQF,IAAMG,CAAC;AAEzB,WAAOD;AAAAA,EACX;AACA,MAAIJ,IAAQ;AACR,WAAO,CAACE,GAAKC,CAAG;AAEpB,QAAMG,KAAQH,IAAMD,MAAQF,IAAQ,IAC9BI,IAAQ,CAAA;AACd,WAASC,IAAI,GAAGA,IAAIL,IAAQ,GAAGK;AAC3B,IAAAD,EAAM,KAAKF,IAAMI,IAAOD,CAAC;AAE7B,SAAAD,EAAM,KAAKD,CAAG,GACPC;AACX;AACA,SAASG,EAAoBP,GAAeC,GAAuBO,GAAiC;AAChG,MAAIA,MAAS;AACT,WAAOT,EAASC,GAAOC,CAAW;AAEtC,MAAIO,MAAS,OAAO;AAChB,UAAMC,IAAcV,EAASC,GAAOC,CAAW,GACzCS,IAAoBC,EAAYV,GAAaA,CAAW,GACxDW,IAAWH,EAAY,IAAI,CAACI,MAAMH,EAAkB,OAAOG,CAAC,CAAC;AACnE,WAAAD,EAAS,CAAC,IAAIX,EAAY,CAAC,GAC3BW,EAASA,EAAS,SAAS,CAAC,IAAIX,EAAY,CAAC,GACtCW;AAAA,EACX;AACA,SAAO,CAAA;AACX;AACO,SAASE,EAAwBC,GAAiBd,GAAuBO,GAAwB;AACpG,UAAQA,MAAS,QAAQG,EAAA,IAAgCK,KACpD,OAAOT,EAAoBQ,EAAO,QAAQd,GAAaO,CAAI,CAAC,EAE5D,MAAMO,CAAM;AACrB;"}

package/dist/utils/getContinuousLegendTicks.d.ts

@@ -0,0 +1,3 @@
+import { ScaleLinear, ScaleSymLog } from 'd3-scale';
+export declare function getContinuousLegendTicks(colorScale: ScaleLinear<string, string> | ScaleLinear<string, number> | ScaleSymLog<string, string, never>, valueExtent: [number, number], tickCount?: number): number[];
+//# sourceMappingURL=getContinuousLegendTicks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getContinuousLegendTicks.d.ts","sourceRoot":"","sources":["../../src/utils/getContinuousLegendTicks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAE,WAAW,EAAC,MAAM,UAAU,CAAC;AAOvD,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAC,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,SAAI,YAoB5L"}

package/dist/utils/getContinuousLegendTicks.js

@@ -0,0 +1,14 @@
+function h(o) {
+  const n = Math.floor(o), s = o - n;
+  return n + Number(s.toPrecision(2));
+}
+function u(o, n, s = 8) {
+  if (n[0] === n[1])
+    return [n[0]];
+  const t = o.ticks(s), i = o.domain(), c = h(i[0]), e = h(i[i.length - 1]), r = Math.abs(t[1] - t[0]) ?? 0;
+  return Math.abs(c - t[0]) > r / 4 ? t.unshift(c) : t[0] = c, Math.abs(e - t[t.length - 1]) > r / 4 ? t.push(e) : t[t.length - 1] = e, t;
+}
+export {
+  u as getContinuousLegendTicks
+};
+//# sourceMappingURL=getContinuousLegendTicks.js.map

package/dist/utils/getContinuousLegendTicks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getContinuousLegendTicks.js","sources":["../../src/utils/getContinuousLegendTicks.ts"],"sourcesContent":["import type {ScaleLinear, ScaleSymLog} from 'd3-scale';\n\nfunction roundEdgeTick(n: number) {\n    const whole = Math.floor(n);\n    const decimal = n - whole;\n    return whole + Number(decimal.toPrecision(2));\n}\nexport function getContinuousLegendTicks(colorScale: ScaleLinear<string, string>|ScaleLinear<string, number>|ScaleSymLog<string, string, never>, valueExtent: [number, number], tickCount = 8) {\n    if (valueExtent[0] === valueExtent[1]) {\n        return [valueExtent[0]];\n    }\n    const scaleTicks = colorScale.ticks(tickCount);\n    const colorDomain = colorScale.domain();\n    const from = roundEdgeTick(colorDomain[0]);\n    const to = roundEdgeTick(colorDomain[colorDomain.length - 1]);\n    const tickStep = Math.abs(scaleTicks[1] - scaleTicks[0]) ?? 0;\n    if (Math.abs(from - scaleTicks[0]) > tickStep / 4) {\n        scaleTicks.unshift(from);\n    } else {\n        scaleTicks[0] = from;\n    }\n    if (Math.abs(to - scaleTicks[scaleTicks.length - 1]) > tickStep / 4) {\n        scaleTicks.push(to);\n    } else {\n        scaleTicks[scaleTicks.length - 1] = to;\n    }\n    return scaleTicks;\n}"],"names":["roundEdgeTick","n","whole","decimal","getContinuousLegendTicks","colorScale","valueExtent","tickCount","scaleTicks","colorDomain","from","to","tickStep"],"mappings":"AAEA,SAASA,EAAcC,GAAW;AAC9B,QAAMC,IAAQ,KAAK,MAAMD,CAAC,GACpBE,IAAUF,IAAIC;AACpB,SAAOA,IAAQ,OAAOC,EAAQ,YAAY,CAAC,CAAC;AAChD;AACO,SAASC,EAAyBC,GAAwGC,GAA+BC,IAAY,GAAG;AAC3L,MAAID,EAAY,CAAC,MAAMA,EAAY,CAAC;AAChC,WAAO,CAACA,EAAY,CAAC,CAAC;AAE1B,QAAME,IAAaH,EAAW,MAAME,CAAS,GACvCE,IAAcJ,EAAW,OAAA,GACzBK,IAAOV,EAAcS,EAAY,CAAC,CAAC,GACnCE,IAAKX,EAAcS,EAAYA,EAAY,SAAS,CAAC,CAAC,GACtDG,IAAW,KAAK,IAAIJ,EAAW,CAAC,IAAIA,EAAW,CAAC,CAAC,KAAK;AAC5D,SAAI,KAAK,IAAIE,IAAOF,EAAW,CAAC,CAAC,IAAII,IAAW,IAC5CJ,EAAW,QAAQE,CAAI,IAEvBF,EAAW,CAAC,IAAIE,GAEhB,KAAK,IAAIC,IAAKH,EAAWA,EAAW,SAAS,CAAC,CAAC,IAAII,IAAW,IAC9DJ,EAAW,KAAKG,CAAE,IAElBH,EAAWA,EAAW,SAAS,CAAC,IAAIG,GAEjCH;AACX;"}

package/dist/utils/getKeysCombination.d.ts

@@ -0,0 +1,2 @@
+export declare function getKeysCombinations(keysLists: string[][]): string[][];
+//# sourceMappingURL=getKeysCombination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getKeysCombination.d.ts","sourceRoot":"","sources":["../../src/utils/getKeysCombination.ts"],"names":[],"mappings":"AACA,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,cAaxD"}

package/dist/utils/getKeysCombination.js

@@ -0,0 +1,15 @@
+function a(e) {
+  if (!e.length)
+    return [];
+  let t = [[]];
+  return e.forEach((r) => {
+    const n = [];
+    r.forEach((o) => {
+      n.push(...t.map((u) => [...u, o]));
+    }), t = n;
+  }), t;
+}
+export {
+  a as getKeysCombinations
+};
+//# sourceMappingURL=getKeysCombination.js.map

package/dist/utils/getKeysCombination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getKeysCombination.js","sources":["../../src/utils/getKeysCombination.ts"],"sourcesContent":["// all combinations with 1 key from each list\nexport function getKeysCombinations(keysLists: string[][]) {\n    if (!keysLists.length) {\n        return [];\n    }\n    let result: string[][] = [[]];\n    keysLists.forEach(keys => {\n        const nextResult: string[][] = [];\n        keys.forEach(key => {\n            nextResult.push(...result.map(resultItem => [...resultItem, key]));\n        });\n        result = nextResult;\n    });\n    return result;\n}"],"names":["getKeysCombinations","keysLists","result","keys","nextResult","key","resultItem"],"mappings":"AACO,SAASA,EAAoBC,GAAuB;AACvD,MAAI,CAACA,EAAU;AACX,WAAO,CAAA;AAEX,MAAIC,IAAqB,CAAC,EAAE;AAC5B,SAAAD,EAAU,QAAQ,CAAAE,MAAQ;AACtB,UAAMC,IAAyB,CAAA;AAC/B,IAAAD,EAAK,QAAQ,CAAAE,MAAO;AAChB,MAAAD,EAAW,KAAK,GAAGF,EAAO,IAAI,CAAAI,MAAc,CAAC,GAAGA,GAAYD,CAAG,CAAC,CAAC;AAAA,IACrE,CAAC,GACDH,IAASE;AAAA,EACb,CAAC,GACMF;AACX;"}

package/dist/utils/getLegendWidth.d.ts

@@ -0,0 +1,4 @@
+import { ScaleOrdinal } from 'd3-scale';
+export declare function getContinuousLegendWidth(scaleTicks: number[], title: string): number;
+export declare function getDiscreteLegendWidth(scale: ScaleOrdinal<string, string>, title: string): number;
+//# sourceMappingURL=getLegendWidth.d.ts.map

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

@@ -0,0 +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"}

package/dist/utils/getLegendWidth.js

@@ -0,0 +1,19 @@
+import { TextMeasurer as r } from "./TextMeasurer.js";
+const t = new r("bold 14px Arial"), T = 20, o = 24;
+function d(e, n) {
+  return Math.max(
+    ...e.map((i) => t.getTextWidth(String(i)) + o),
+    t.getTextWidth(n)
+  );
+}
+function g(e, n) {
+  return Math.max(
+    ...e.domain().map((i) => t.getTextWidth(String(i)) + T),
+    t.getTextWidth(n)
+  );
+}
+export {
+  d as getContinuousLegendWidth,
+  g as getDiscreteLegendWidth
+};
+//# sourceMappingURL=getLegendWidth.js.map

package/dist/utils/getLegendWidth.js.map

@@ -0,0 +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;"}

package/dist/utils/getLineShape.d.ts

@@ -0,0 +1,3 @@
+import { LineShape } from '../types';
+export declare function getLineShape(lineShapeName?: LineShape | null): "" | "6 6" | "1.5 4" | "1.4 4 8 4" | "10 4" | "3 3 9 3";
+//# sourceMappingURL=getLineShape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLineShape.d.ts","sourceRoot":"","sources":["../../src/utils/getLineShape.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AAGxC,wBAAgB,YAAY,CAAE,aAAa,GAAC,SAAS,GAAC,IAAW,2DAWhE"}

package/dist/utils/getLineShape.js

@@ -0,0 +1,25 @@
+import { exhaustive as t } from "./index.js";
+function n(e = null) {
+  switch (e) {
+    case null:
+      return "";
+    case "solid":
+      return "";
+    case "dashed":
+      return "6 6";
+    case "dotted":
+      return "1.5 4";
+    case "dotdash":
+      return "1.4 4 8 4";
+    case "longdash":
+      return "10 4";
+    case "twodash":
+      return "3 3 9 3";
+    default:
+      t(e, `Unknown line shape ${e}`);
+  }
+}
+export {
+  n as getLineShape
+};
+//# sourceMappingURL=getLineShape.js.map

package/dist/utils/getLineShape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLineShape.js","sources":["../../src/utils/getLineShape.ts"],"sourcesContent":["import type {LineShape} from '../types';\nimport {exhaustive} from './index';\n\nexport function getLineShape (lineShapeName:LineShape|null = null) {\n    switch (lineShapeName) {\n        case null: return '';\n        case 'solid': return '';\n        case 'dashed': return '6 6';\n        case 'dotted': return '1.5 4';\n        case 'dotdash': return '1.4 4 8 4';\n        case 'longdash': return '10 4';\n        case 'twodash': return '3 3 9 3';\n        default: exhaustive(lineShapeName, `Unknown line shape ${lineShapeName}`);\n    }\n}\n"],"names":["getLineShape","lineShapeName","exhaustive"],"mappings":";AAGO,SAASA,EAAcC,IAA+B,MAAM;AAC/D,UAAQA,GAAA;AAAA,IACJ,KAAK;AAAM,aAAO;AAAA,IAClB,KAAK;AAAS,aAAO;AAAA,IACrB,KAAK;AAAU,aAAO;AAAA,IACtB,KAAK;AAAU,aAAO;AAAA,IACtB,KAAK;AAAW,aAAO;AAAA,IACvB,KAAK;AAAY,aAAO;AAAA,IACxB,KAAK;AAAW,aAAO;AAAA,IACvB;AAAS,MAAAC,EAAWD,GAAe,sBAAsBA,CAAa,EAAE;AAAA,EAAA;AAEhF;"}

package/dist/utils/getPointShape.d.ts

@@ -0,0 +1,3 @@
+import { PointShape } from '../types';
+export declare function getPointShape(shape: PointShape | null, size?: number, fillColor?: string, strokeColor?: string | null): "" | import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=getPointShape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getPointShape.d.ts","sourceRoot":"","sources":["../../src/utils/getPointShape.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAQzC,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,EAAE,IAAI,SAAI,EAAE,SAAS,SAAQ,EAAE,WAAW,GAAC,MAAM,GAAC,IAAW,gDAyOlH"}