@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/g2/esm/data/wordCloud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wordCloud.js","sources":["../../../../../../node_modules/@antv/g2/esm/data/wordCloud.js"],"sourcesContent":["var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { min, max } from '@antv/vendor/d3-array';\nimport { flow } from './utils/flow';\nimport { tagCloud } from './utils/d3-cloud';\nconst DEFAULT_OPTIONS = {\n    fontSize: [20, 60],\n    font: 'Impact',\n    padding: 2,\n    rotate: function () {\n        return (~~(Math.random() * 6) - 3) * 30;\n    },\n};\n/**\n * Process the image mask of wordCloud.\n * @param img\n * @returns\n */\nexport function processImageMask(img) {\n    return new Promise((res, rej) => {\n        if (img instanceof HTMLImageElement) {\n            res(img);\n            return;\n        }\n        if (typeof img === 'string') {\n            const image = new Image();\n            image.crossOrigin = 'anonymous';\n            image.src = img;\n            image.onload = () => res(image);\n            image.onerror = () => {\n                console.error(`'image ${img} load failed !!!'`);\n                rej();\n            };\n            return;\n        }\n        rej();\n    });\n}\n/**\n * normalize fontSize range to d3-cloud fontSize function.\n * @param fontSize\n * @param range\n * @returns\n */\nexport function normalizeFontSize(fontSize, range) {\n    if (typeof fontSize === 'function')\n        return fontSize;\n    if (Array.isArray(fontSize)) {\n        const [fMin, fMax] = fontSize;\n        if (!range)\n            return () => (fMax + fMin) / 2;\n        const [min, max] = range;\n        if (max === min)\n            return () => (fMax + fMin) / 2;\n        return ({ value }) => ((fMax - fMin) / (max - min)) * (value - min) + fMin;\n    }\n    return () => fontSize;\n}\nexport const WordCloud = (options, context) => {\n    return (data) => __awaiter(void 0, void 0, void 0, function* () {\n        const cloudOptions = Object.assign({}, DEFAULT_OPTIONS, options, {\n            canvas: context.createCanvas,\n        });\n        const layout = tagCloud();\n        yield flow(layout, cloudOptions)\n            .set('fontSize', (v) => {\n            const arr = data.map((d) => d.value);\n            return normalizeFontSize(v, [min(arr), max(arr)]);\n        })\n            .set('font')\n            .set('fontStyle')\n            .set('fontWeight')\n            .set('padding')\n            .set('rotate')\n            .set('size')\n            .set('spiral')\n            .set('timeInterval')\n            .set('random')\n            .set('text')\n            .set('on')\n            .set('canvas')\n            .setAsync('imageMask', processImageMask, layout.createMask);\n        layout.words([...data]);\n        const result = layout.start();\n        const [cw, ch] = cloudOptions.size;\n        const defaultBounds = [\n            { x: 0, y: 0 },\n            { x: cw, y: ch },\n        ];\n        const { _bounds: bounds = defaultBounds, _tags, hasImage } = result;\n        const tags = _tags.map((_a) => {\n            var { x, y, font } = _a, rest = __rest(_a, [\"x\", \"y\", \"font\"]);\n            return (Object.assign(Object.assign({}, rest), { x: x + cw / 2, y: y + ch / 2, fontFamily: font }));\n        });\n        // Append two data to replace the corner of top-left and bottom-right, avoid calculate the actual bounds will occur some error.\n        const [{ x: tlx, y: tly }, { x: brx, y: bry }] = bounds;\n        const invisibleText = { text: '', value: 0, opacity: 0, fontSize: 0 };\n        tags.push(Object.assign(Object.assign({}, invisibleText), { x: hasImage ? 0 : tlx, y: hasImage ? 0 : tly }), Object.assign(Object.assign({}, invisibleText), { x: hasImage ? cw : brx, y: hasImage ? ch : bry }));\n        return tags;\n    });\n};\nWordCloud.props = {};\n//# sourceMappingURL=wordCloud.js.map"],"names":["__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","reject","fulfilled","step","e","rejected","result","__rest","s","t","p","i","DEFAULT_OPTIONS","processImageMask","img","res","rej","image","normalizeFontSize","fontSize","range","fMin","fMax","min","max","WordCloud","options","context","data","cloudOptions","layout","tagCloud","flow","v","arr","d","cw","ch","defaultBounds","bounds","_tags","hasImage","tags","_a","x","y","font","rest","tlx","tly","brx","bry","invisibleText"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/encode/column.js

@@ -0,0 +1,6 @@
+const r = ({ value: o }) => () => o;
+r.props = {};
+export {
+  r as Column
+};
+//# sourceMappingURL=column.js.map

package/dist/node_modules/@antv/g2/esm/encode/column.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.js","sources":["../../../../../../node_modules/@antv/g2/esm/encode/column.js"],"sourcesContent":["/**\n * Extract a column of data specified in encoding.\n */\nexport const Column = ({ value }) => {\n    return () => value;\n};\nColumn.props = {};\n//# sourceMappingURL=column.js.map"],"names":["Column","value"],"mappings":"AAGY,MAACA,IAAS,CAAC,EAAE,OAAAC,QACd,MAAMA;AAEjBD,EAAO,QAAQ,CAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/encode/constant.js

@@ -0,0 +1,6 @@
+const o = ({ value: t }) => (n) => n.map(() => t);
+o.props = {};
+export {
+  o as Constant
+};
+//# sourceMappingURL=constant.js.map

package/dist/node_modules/@antv/g2/esm/encode/constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.js","sources":["../../../../../../node_modules/@antv/g2/esm/encode/constant.js"],"sourcesContent":["/**\n * Extract a column of data filled with the specified constant.\n */\nexport const Constant = ({ value }) => {\n    return (data) => data.map(() => value);\n};\nConstant.props = {};\n//# sourceMappingURL=constant.js.map"],"names":["Constant","value","data"],"mappings":"AAGY,MAACA,IAAW,CAAC,EAAE,OAAAC,QAChB,CAACC,MAASA,EAAK,IAAI,MAAMD,CAAK;AAEzCD,EAAS,QAAQ,CAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/encode/field.js

@@ -0,0 +1,6 @@
+const o = ({ value: p }) => (r) => r.map((e) => e[p]);
+o.props = {};
+export {
+  o as Field
+};
+//# sourceMappingURL=field.js.map

package/dist/node_modules/@antv/g2/esm/encode/field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.js","sources":["../../../../../../node_modules/@antv/g2/esm/encode/field.js"],"sourcesContent":["/**\n * Extract a column of data with specified field.\n */\nexport const Field = ({ value }) => {\n    return (data) => data.map((d) => d[value]);\n};\nField.props = {};\n//# sourceMappingURL=field.js.map"],"names":["Field","value","data","d"],"mappings":"AAGY,MAACA,IAAQ,CAAC,EAAE,OAAAC,QACb,CAACC,MAASA,EAAK,IAAI,CAACC,MAAMA,EAAEF,CAAK,CAAC;AAE7CD,EAAM,QAAQ,CAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/encode/transform.js

@@ -0,0 +1,6 @@
+const p = ({ value: r }) => (o) => o.map(r);
+p.props = {};
+export {
+  p as Transform
+};
+//# sourceMappingURL=transform.js.map

package/dist/node_modules/@antv/g2/esm/encode/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sources":["../../../../../../node_modules/@antv/g2/esm/encode/transform.js"],"sourcesContent":["/**\n * Extract a column of data with specified map function from data.\n * Each datum in the array is not visual data by default.\n * Specifying identity scale for related channel explicitly will treat them as visual data.\n */\nexport const Transform = ({ value }) => {\n    return (data) => data.map(value);\n};\nTransform.props = {};\n//# sourceMappingURL=transform.js.map"],"names":["Transform","value","data"],"mappings":"AAKY,MAACA,IAAY,CAAC,EAAE,OAAAC,QACjB,CAACC,MAASA,EAAK,IAAID,CAAK;AAEnCD,EAAU,QAAQ,CAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/index.js

@@ -0,0 +1,151 @@
+import { ChartEvent as l } from "./utils/event.js";
+import { Selection as S, select as b } from "./utils/selection.js";
+import { dataOf as y, seriesOf as n } from "./utils/helper.js";
+import { selectG2Elements as s, selectPlotArea as _ } from "./interaction/utils.js";
+import { LinearAxis as L } from "./component/axis.js";
+import { extend as r } from "./api/extend.js";
+import { stdlib as o } from "./lib/std.js";
+import { Runtime as e } from "./api/runtime.js";
+import { corelib as Y } from "./lib/core.js";
+import { geolib as N } from "./lib/geo.js";
+import { graphlib as X } from "./lib/graph.js";
+import { litelib as g } from "./lib/lite.js";
+import { plotlib as D } from "./lib/plot.js";
+import { AREA_CLASS_NAME as O, COMPONENT_CLASS_NAME as P, ELEMENT_CLASS_NAME as Z, LABEL_CLASS_NAME as h, LABEL_LAYER_CLASS_NAME as B, MAIN_LAYER_CLASS_NAME as I, MASK_CLASS_NAME as R, PLOT_CLASS_NAME as F, VIEW_CLASS_NAME as J } from "./runtime/constant.js";
+import { Academy as K } from "./theme/academy.js";
+import { Bin as j } from "./transform/bin.js";
+import { BinX as W } from "./transform/binX.js";
+import { Classic as w } from "./theme/classic.js";
+import { ClassicDark as Q } from "./theme/classicDark.js";
+import { Dark as $ } from "./theme/dark.js";
+import { DiffY as or } from "./transform/diffY.js";
+import { DodgeX as tr } from "./transform/dodgeX.js";
+import { Filter as mr } from "./transform/filter.js";
+import { FlexX as xr } from "./transform/flexX.js";
+import { Group as ir } from "./transform/group.js";
+import { GroupColor as Mr } from "./transform/groupColor.js";
+import { GroupX as br } from "./transform/groupX.js";
+import { GroupY as yr } from "./transform/groupY.js";
+import { Jitter as Er } from "./transform/jitter.js";
+import { JitterX as _r } from "./transform/jitterX.js";
+import { JitterY as Lr } from "./transform/jitterY.js";
+import { Light as Yr } from "./theme/light.js";
+import { MaybeDefaultX as Nr } from "./transform/maybeDefaultX.js";
+import { MaybeDefaultY as Xr } from "./transform/maybeDefaultY.js";
+import { MaybeFunctionAttribute as gr } from "./transform/maybeFunctionAttribute.js";
+import { MaybeGradient as Dr } from "./transform/maybeGradient.js";
+import { MaybeIdentityX as Or } from "./transform/maybeIdentityX.js";
+import { MaybeIdentityY as Zr } from "./transform/maybeIdentityY.js";
+import { MaybeKey as Br } from "./transform/maybeKey.js";
+import { MaybeSeries as Rr } from "./transform/maybeSeries.js";
+import { MaybeSize as Jr } from "./transform/maybeSize.js";
+import { MaybeStackY as Kr } from "./transform/maybeStackY.js";
+import { MaybeTitle as jr } from "./transform/maybeTitle.js";
+import { MaybeTooltip as Wr } from "./transform/maybeTooltip.js";
+import { MaybeTuple as wr } from "./transform/maybeTuple.js";
+import { MaybeTupleX as Qr } from "./transform/maybeTupleX.js";
+import { MaybeTupleY as $r } from "./transform/maybeTupleY.js";
+import { MaybeVisualPosition as oo } from "./transform/maybeVisualPosition.js";
+import { MaybeZeroPadding as to } from "./transform/maybeZeroPadding.js";
+import { MaybeZeroX as mo } from "./transform/maybeZeroX.js";
+import { MaybeZeroY as xo } from "./transform/maybeZeroY.js";
+import { MaybeZeroY1 as io } from "./transform/maybeZeroY1.js";
+import { MaybeZeroZ as Mo } from "./transform/maybeZeroZ.js";
+import { NormalizeY as bo } from "./transform/normalizeY.js";
+import { Pack as yo } from "./transform/pack.js";
+import { Sample as Eo } from "./transform/sample.js";
+import { Select as _o } from "./transform/select.js";
+import { SelectX as Lo } from "./transform/selectX.js";
+import { SelectY as Yo } from "./transform/selectY.js";
+import { SortColor as No } from "./transform/sortColor.js";
+import { SortX as To } from "./transform/sortX.js";
+import { SortY as ko } from "./transform/sortY.js";
+import { StackEnter as Go } from "./transform/stackEnter.js";
+import { StackY as Po } from "./transform/stackY.js";
+import { SymmetryY as ho } from "./transform/symmetryY.js";
+import { register as Io } from "./api/library.js";
+import { render as Fo, renderToMountedElement as Jo } from "./runtime/render.js";
+const t = Object.assign({}, o()), x = r(e, t);
+export {
+  O as AREA_CLASS_NAME,
+  K as Academy,
+  j as Bin,
+  W as BinX,
+  P as COMPONENT_CLASS_NAME,
+  x as Chart,
+  l as ChartEvent,
+  w as Classic,
+  Q as ClassicDark,
+  $ as Dark,
+  or as DiffY,
+  tr as DodgeX,
+  Z as ELEMENT_CLASS_NAME,
+  mr as Filter,
+  xr as FlexX,
+  ir as Group,
+  Mr as GroupColor,
+  br as GroupX,
+  yr as GroupY,
+  Er as Jitter,
+  _r as JitterX,
+  Lr as JitterY,
+  h as LABEL_CLASS_NAME,
+  B as LABEL_LAYER_CLASS_NAME,
+  Yr as Light,
+  L as LinearAxis,
+  I as MAIN_LAYER_CLASS_NAME,
+  R as MASK_CLASS_NAME,
+  Nr as MaybeDefaultX,
+  Xr as MaybeDefaultY,
+  gr as MaybeFunctionAttribute,
+  Dr as MaybeGradient,
+  Or as MaybeIdentityX,
+  Zr as MaybeIdentityY,
+  Br as MaybeKey,
+  Rr as MaybeSeries,
+  Jr as MaybeSize,
+  Kr as MaybeStackY,
+  jr as MaybeTitle,
+  Wr as MaybeTooltip,
+  wr as MaybeTuple,
+  Qr as MaybeTupleX,
+  $r as MaybeTupleY,
+  oo as MaybeVisualPosition,
+  to as MaybeZeroPadding,
+  mo as MaybeZeroX,
+  xo as MaybeZeroY,
+  io as MaybeZeroY1,
+  Mo as MaybeZeroZ,
+  bo as NormalizeY,
+  F as PLOT_CLASS_NAME,
+  yo as Pack,
+  e as Runtime,
+  Eo as Sample,
+  _o as Select,
+  Lo as SelectX,
+  Yo as SelectY,
+  S as Selection,
+  No as SortColor,
+  To as SortX,
+  ko as SortY,
+  Go as StackEnter,
+  Po as StackY,
+  ho as SymmetryY,
+  J as VIEW_CLASS_NAME,
+  Y as corelib,
+  y as dataOf,
+  r as extend,
+  N as geolib,
+  X as graphlib,
+  g as litelib,
+  D as plotlib,
+  Io as register,
+  Fo as render,
+  Jo as renderToMountedElement,
+  b as select,
+  s as selectG2Elements,
+  _ as selectPlotArea,
+  n as seriesOf,
+  o as stdlib
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@antv/g2/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/@antv/g2/esm/index.js"],"sourcesContent":["import { litelib, corelib, plotlib, graphlib, geolib, stdlib } from './lib';\nimport { extend, Runtime } from './api';\nexport { litelib, corelib, plotlib, graphlib, geolib, stdlib };\nexport * from './exports';\n/**\n * G2 standard library initial all the libs except 3D and auto.\n */\nconst library = Object.assign({}, stdlib());\nexport const Chart = extend(Runtime, library);\n//# sourceMappingURL=index.js.map"],"names":["library","stdlib","Chart","extend","Runtime"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,MAAMA,IAAU,OAAO,OAAO,CAAA,GAAIC,EAAM,CAAE,GAC7BC,IAAQC,EAAOC,GAASJ,CAAO;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/interaction/adaptiveFilter.js

@@ -0,0 +1,128 @@
+import { isOrdinalScale as N } from "../utils/scale.js";
+import { isFalsyValue as K } from "./utils.js";
+function w(e, t, c) {
+  const s = e ? c : t, r = e ? t : c, i = N(s), a = N(r), o = r.getOptions().domain, u = !a && o && o.length >= 2 && o[0] === 0;
+  return {
+    currentScale: s,
+    targetScale: r,
+    isSourceDiscrete: i,
+    isTargetDiscrete: a,
+    shouldPreserveZeroBaseline: u
+  };
+}
+function E(e, t, c, s, r) {
+  const i = e ? s : c, a = (n) => {
+    const l = {};
+    return Object.keys(r).forEach((f) => {
+      (f === n || f.match(new RegExp(`^${n}\\d+$`))) && (l[f] = r[f]);
+    }), l;
+  }, o = a(e ? "x" : "y"), u = Object.keys(o), g = u.map((n) => t[n]), S = N(i), m = g.map((n) => N(n)), h = g.map((n, l) => {
+    const f = n.getOptions().domain;
+    return !m[l] && f && f.length >= 2 && f[0] === 0;
+  });
+  return {
+    currentScale: i,
+    targetScales: g,
+    isSourceDiscrete: S,
+    isTargetDiscrete: m,
+    shouldPreserveZeroBaseline: h,
+    targetScaleKeys: u
+  };
+}
+function k(e) {
+  return Array.from(new Set(e)).sort((c, s) => c - s);
+}
+function F({ isTargetDiscrete: e, filteredValues: t, shouldPreserveZeroBaseline: c }) {
+  if (e)
+    return k(t);
+  {
+    const s = Math.min(...t), r = Math.max(...t);
+    return c ? [0, r] : [s, r];
+  }
+}
+function A(e) {
+  return e instanceof Date ? e.getTime() : typeof e == "string" ? parseFloat(e) : Number(e);
+}
+function T(e, t, c, s, r, i = "filter", a = !1) {
+  if (K(i))
+    return [];
+  const o = a ? "y" : "x", u = a ? "x" : "y", g = [];
+  for (const S of e) {
+    const { channelData: m } = S, h = m[o] || [], n = m[u] || [], l = Array.isArray(h[0]) ? h[0] : h, f = Array.isArray(n[0]);
+    if (l.length === 0)
+      continue;
+    const V = l.length;
+    for (let D = 0; D < V; D++) {
+      const M = l[D];
+      let d = !1;
+      if (c)
+        d = t.includes(M);
+      else if (t.length >= 2) {
+        const p = A(M), y = A(t[0]), x = A(t[t.length - 1]);
+        !isNaN(p) && !isNaN(y) && !isNaN(x) && (d = p >= y && p <= x);
+      }
+      if (i === "filter" && d) {
+        if (f) {
+          const p = n.length;
+          for (let y = 0; y < p; y++) {
+            const x = n[y];
+            if (Array.isArray(x) && D < x.length) {
+              const B = x[D], O = A(B);
+              isNaN(O) || g.push(O);
+            }
+          }
+        } else if (D < n.length) {
+          const p = n[D], y = A(p);
+          isNaN(y) || g.push(y);
+        }
+      }
+    }
+  }
+  return g.length > 0 ? F({
+    isTargetDiscrete: s,
+    filteredValues: g,
+    shouldPreserveZeroBaseline: r
+  }) : [];
+}
+function C({ markDataPairs: e, domain: t, scaleInfo: c, adaptiveMode: s, shouldFilterXAxis: r = !1 }) {
+  const { isSourceDiscrete: i, isTargetDiscrete: a, shouldPreserveZeroBaseline: o } = c;
+  return T(e, t, i, a, o, s, r);
+}
+function P({ markDataPairs: e, domain: t, scaleInfo: c, markToScaleMap: s, adaptiveMode: r, shouldFilterXAxis: i = !1 }) {
+  const a = /* @__PURE__ */ new Map(), { isSourceDiscrete: o, isTargetDiscrete: u, shouldPreserveZeroBaseline: g, targetScaleKeys: S } = c;
+  return e.forEach((m) => {
+    const h = s.get(m.markKey);
+    if (!h)
+      return;
+    const n = S.indexOf(h);
+    if (n === -1)
+      return;
+    const l = u[n], f = g[n], V = T([m], t, o, l, f, r, i);
+    a.set(h, V);
+  }), a;
+}
+function b(e, t, c, s, r, i, a = !1, o) {
+  const u = /* @__PURE__ */ new Map();
+  if (e.length === 0 || t.length === 0)
+    return u;
+  const { isSourceDiscrete: g, isTargetDiscrete: S, shouldPreserveZeroBaseline: m } = c, h = o ? e.filter((l) => o.get(l.markKey) === r) : e.filter((l) => l.markKey === s);
+  if (h.length === 0)
+    return u;
+  const n = T(h, t, g, S, m, i, a);
+  return u.set(r, n), u;
+}
+function q(e, t, c, s) {
+  s && t instanceof Map ? t.forEach((r, i) => {
+    r && Array.isArray(r) && r.length > 0 && (e[i] = r);
+  }) : !s && Array.isArray(t) && t.length > 0 && (e[c ? "x" : "y"] = t);
+}
+export {
+  E as extractMultiAxisScaleInfo,
+  w as extractSingleAxisScaleInfo,
+  T as filterMarkDataByDomain,
+  b as processMultiAxisMarkFiltering,
+  P as processMultiAxisViewFiltering,
+  C as processSingleAxisFiltering,
+  q as updateChannelDomains
+};
+//# sourceMappingURL=adaptiveFilter.js.map

package/dist/node_modules/@antv/g2/esm/interaction/adaptiveFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptiveFilter.js","sources":["../../../../../../node_modules/@antv/g2/esm/interaction/adaptiveFilter.js"],"sourcesContent":["import { isOrdinalScale } from '../utils/scale';\nimport { isFalsyValue } from './utils';\n/**\n * Extracts scale information for single-axis adaptive filtering.\n *\n * @param shouldFilterXAxis - Whether to adapt X-axis (true) or Y-axis (false)\n * @param scaleX - X-axis scale instance\n * @param scaleY - Y-axis scale instance\n * @returns Scale information required for single-axis filtering\n */\nexport function extractSingleAxisScaleInfo(shouldFilterXAxis, scaleX, scaleY) {\n    const currentScale = shouldFilterXAxis ? scaleY : scaleX;\n    const targetScale = shouldFilterXAxis ? scaleX : scaleY;\n    const isSourceDiscrete = isOrdinalScale(currentScale);\n    const isTargetDiscrete = isOrdinalScale(targetScale);\n    const targetOriginalDomain = targetScale.getOptions().domain;\n    const shouldPreserveZeroBaseline = !isTargetDiscrete &&\n        targetOriginalDomain &&\n        targetOriginalDomain.length >= 2 &&\n        targetOriginalDomain[0] === 0;\n    return {\n        currentScale,\n        targetScale,\n        isSourceDiscrete,\n        isTargetDiscrete,\n        shouldPreserveZeroBaseline,\n    };\n}\n/**\n * Extracts scale information for multi-axis adaptive filtering.\n * Handles scenarios where multiple independent scales exist (x1, x2, y1, y2, etc.).\n *\n * @param shouldFilterXAxis - Whether to adapt X-axis (true) or Y-axis (false)\n * @param scale - Record of all available scale instances\n * @param scaleX - Primary X-axis scale instance\n * @param scaleY - Primary Y-axis scale instance\n * @param channelDomain - Channel domain configuration\n * @returns Scale information required for multi-axis filtering\n */\nexport function extractMultiAxisScaleInfo(shouldFilterXAxis, scale, scaleX, scaleY, channelDomain) {\n    const currentScale = shouldFilterXAxis ? scaleY : scaleX;\n    /**\n     * Retrieves scale domains for a specific axis type (x or y).\n     * Supports both primary axes (x, y) and numbered variants (x1, x2, y1, y2).\n     */\n    const getAxisScaleDomains = (axisType) => {\n        const axisScales = {};\n        Object.keys(channelDomain).forEach((key) => {\n            if (key === axisType || key.match(new RegExp(`^${axisType}\\\\d+$`))) {\n                axisScales[key] = channelDomain[key];\n            }\n        });\n        return axisScales;\n    };\n    const targetScaleDomain = shouldFilterXAxis\n        ? getAxisScaleDomains('x')\n        : getAxisScaleDomains('y');\n    const targetScaleKeys = Object.keys(targetScaleDomain);\n    const targetScales = targetScaleKeys.map((item) => scale[item]);\n    const isSourceDiscrete = isOrdinalScale(currentScale);\n    const isTargetDiscrete = targetScales.map((targetScale) => isOrdinalScale(targetScale));\n    const shouldPreserveZeroBaseline = targetScales.map((targetScale, index) => {\n        const targetOriginalDomain = targetScale.getOptions().domain;\n        const isDiscrete = isTargetDiscrete[index];\n        return (!isDiscrete &&\n            targetOriginalDomain &&\n            targetOriginalDomain.length >= 2 &&\n            targetOriginalDomain[0] === 0);\n    });\n    return {\n        currentScale,\n        targetScales,\n        isSourceDiscrete,\n        isTargetDiscrete,\n        shouldPreserveZeroBaseline,\n        targetScaleKeys,\n    };\n}\n/**\n * Removes duplicate values from an array and returns sorted result.\n *\n * @param values - Array of numeric values\n * @returns Sorted array with unique values\n */\nfunction getUniqueSortedValues(values) {\n    const uniqueValues = Array.from(new Set(values));\n    return uniqueValues.sort((a, b) => a - b);\n}\n/**\n * Calculates the filtered domain based on target scale type and constraints.\n *\n * @param options - Configuration for domain calculation\n * @returns Calculated domain array\n */\nfunction calculateFilteredDomain({ isTargetDiscrete, filteredValues, shouldPreserveZeroBaseline, }) {\n    if (isTargetDiscrete) {\n        return getUniqueSortedValues(filteredValues);\n    }\n    else {\n        const min = Math.min(...filteredValues);\n        const max = Math.max(...filteredValues);\n        return shouldPreserveZeroBaseline ? [0, max] : [min, max];\n    }\n}\n/**\n * Converts various value types to numeric for comparison.\n * Handles Date objects, strings, and numbers.\n */\nfunction convertToNumeric(value) {\n    if (value instanceof Date) {\n        return value.getTime();\n    }\n    if (typeof value === 'string') {\n        return parseFloat(value);\n    }\n    return Number(value);\n}\n/**\n * Filters mark data based on domain constraints with bidirectional support.\n * Supports both discrete and continuous scales with proper domain calculation.\n *\n * @param markDataPairs - Array of mark data with channel information\n * @param domain - Domain values for filtering\n * @param isSourceDiscrete - Whether the source scale is discrete\n * @param isTargetDiscrete - Whether the target scale is discrete\n * @param shouldPreserveZeroBaseline - Whether to preserve zero baseline for continuous scales\n * @param adaptiveMode - Adaptive filtering mode configuration\n * @param shouldFilterXAxis - Whether to adapt X-axis (true) or Y-axis (false)\n * @returns Filtered domain array\n */\nexport function filterMarkDataByDomain(markDataPairs, domain, isSourceDiscrete, isTargetDiscrete, shouldPreserveZeroBaseline, adaptiveMode = 'filter', shouldFilterXAxis = false) {\n    if (isFalsyValue(adaptiveMode)) {\n        return [];\n    }\n    const sourceChannel = shouldFilterXAxis ? 'y' : 'x';\n    const targetChannel = shouldFilterXAxis ? 'x' : 'y';\n    const allFilteredTargetValues = [];\n    for (const markData of markDataPairs) {\n        const { channelData } = markData;\n        const sourceValues = channelData[sourceChannel] || [];\n        const targetValues = channelData[targetChannel] || [];\n        // Handle different data structures based on channel type:\n        // X channel: one-dimensional array [x1, x2, x3, ...]\n        // Y channel: two-dimensional array [[y1, y2, y3, ...]]\n        // Normalize source values to one-dimensional array\n        const normalizedSourceValues = Array.isArray(sourceValues[0])\n            ? sourceValues[0] // If it's 2D array (Y channel), take first sub-array\n            : sourceValues; // If it's 1D array (X channel), use as is\n        // Handle target values based on their structure\n        const isTargetArray2D = Array.isArray(targetValues[0]);\n        if (normalizedSourceValues.length === 0)\n            continue;\n        const dataLength = normalizedSourceValues.length;\n        for (let i = 0; i < dataLength; i++) {\n            const sourceValue = normalizedSourceValues[i];\n            let shouldInclude = false;\n            if (isSourceDiscrete) {\n                shouldInclude = domain.includes(sourceValue);\n            }\n            else {\n                // Handle both numeric and Date domains\n                if (domain.length >= 2) {\n                    const sourceTime = convertToNumeric(sourceValue);\n                    const domainStartTime = convertToNumeric(domain[0]);\n                    const domainEndTime = convertToNumeric(domain[domain.length - 1]);\n                    if (!isNaN(sourceTime) &&\n                        !isNaN(domainStartTime) &&\n                        !isNaN(domainEndTime)) {\n                        shouldInclude =\n                            sourceTime >= domainStartTime && sourceTime <= domainEndTime;\n                    }\n                }\n            }\n            if (adaptiveMode === 'filter' && shouldInclude) {\n                // Collect target channel values for this data point\n                if (isTargetArray2D) {\n                    // Target is 2D array (Y channel)\n                    const numChannels = targetValues.length;\n                    for (let channelIdx = 0; channelIdx < numChannels; channelIdx++) {\n                        const channelData = targetValues[channelIdx];\n                        if (Array.isArray(channelData) && i < channelData.length) {\n                            const targetValue = channelData[i];\n                            const numericValue = convertToNumeric(targetValue);\n                            if (!isNaN(numericValue)) {\n                                allFilteredTargetValues.push(numericValue);\n                            }\n                        }\n                    }\n                }\n                else {\n                    // Target is 1D array (X channel)\n                    if (i < targetValues.length) {\n                        const targetValue = targetValues[i];\n                        const numericValue = convertToNumeric(targetValue);\n                        if (!isNaN(numericValue)) {\n                            allFilteredTargetValues.push(numericValue);\n                        }\n                    }\n                }\n            }\n        }\n    }\n    if (allFilteredTargetValues.length > 0) {\n        return calculateFilteredDomain({\n            isTargetDiscrete,\n            filteredValues: allFilteredTargetValues,\n            shouldPreserveZeroBaseline,\n        });\n    }\n    return [];\n}\n/**\n * Processes adaptive filtering for single-axis scenarios.\n *\n * @param params - Single-axis filtering parameters\n * @returns Filtered domain array\n */\nexport function processSingleAxisFiltering({ markDataPairs, domain, scaleInfo, adaptiveMode, shouldFilterXAxis = false, }) {\n    const { isSourceDiscrete, isTargetDiscrete, shouldPreserveZeroBaseline } = scaleInfo;\n    return filterMarkDataByDomain(markDataPairs, domain, isSourceDiscrete, isTargetDiscrete, shouldPreserveZeroBaseline, adaptiveMode, shouldFilterXAxis);\n}\n/**\n * Processes multi-axis filtering for view-level sliders.\n * Handles scenarios with independent scales across multiple marks.\n *\n * @param params - Multi-axis filtering parameters\n * @returns Map of scale keys to filtered domain arrays\n */\nexport function processMultiAxisViewFiltering({ markDataPairs, domain, scaleInfo, markToScaleMap, adaptiveMode, shouldFilterXAxis = false, }) {\n    const filteredDomain = new Map();\n    const { isSourceDiscrete, isTargetDiscrete, shouldPreserveZeroBaseline, targetScaleKeys, } = scaleInfo;\n    markDataPairs.forEach((markData) => {\n        const scaleKey = markToScaleMap.get(markData.markKey);\n        if (!scaleKey)\n            return;\n        const scaleIndex = targetScaleKeys.indexOf(scaleKey);\n        if (scaleIndex === -1)\n            return;\n        const currentIsTargetDiscrete = isTargetDiscrete[scaleIndex];\n        const currentShouldPreserveZeroBaseline = shouldPreserveZeroBaseline[scaleIndex];\n        const markFilteredDomain = filterMarkDataByDomain([markData], domain, isSourceDiscrete, currentIsTargetDiscrete, currentShouldPreserveZeroBaseline, adaptiveMode, shouldFilterXAxis);\n        filteredDomain.set(scaleKey, markFilteredDomain);\n    });\n    return filteredDomain;\n}\n/**\n * Processes multi-axis filtering for mark-level sliders.\n * Uses all marks that share the same target scale key instead of just the target mark.\n *\n * @param markDataPairs - Array of mark data pairs\n * @param domain - Domain values for filtering\n * @param scaleInfo - Single-axis scale information\n * @param targetMarkKey - Key of the target mark to filter\n * @param targetScaleKey - Key of the target scale to update\n * @param adaptiveMode - Adaptive filtering mode\n * @param shouldFilterXAxis - Whether to adapt X-axis (true) or Y-axis (false)\n * @param markToScaleMap - Map from mark keys to scale keys to identify shared axes\n * @returns Map of scale keys to filtered domain arrays\n */\nexport function processMultiAxisMarkFiltering(markDataPairs, domain, scaleInfo, targetMarkKey, targetScaleKey, adaptiveMode, shouldFilterXAxis = false, markToScaleMap) {\n    const filteredDomain = new Map();\n    // Early return if no data to process\n    if (markDataPairs.length === 0 || domain.length === 0) {\n        return filteredDomain;\n    }\n    const { isSourceDiscrete, isTargetDiscrete, shouldPreserveZeroBaseline } = scaleInfo;\n    // Find all marks that share the same target scale key\n    const relevantMarkData = markToScaleMap\n        ? markDataPairs.filter((markData) => {\n            const markScaleKey = markToScaleMap.get(markData.markKey);\n            return markScaleKey === targetScaleKey;\n        })\n        : markDataPairs.filter((markData) => markData.markKey === targetMarkKey);\n    // Early return if no relevant marks found\n    if (relevantMarkData.length === 0) {\n        return filteredDomain;\n    }\n    const markFilteredDomain = filterMarkDataByDomain(relevantMarkData, domain, isSourceDiscrete, isTargetDiscrete, shouldPreserveZeroBaseline, adaptiveMode, shouldFilterXAxis);\n    filteredDomain.set(targetScaleKey, markFilteredDomain);\n    return filteredDomain;\n}\n/**\n * Updates channel domains with filtered results.\n * Supports both single-axis and multi-axis scenarios.\n *\n * @param channelDomain - Current channel domain configuration\n * @param filteredDomain - Filtered domain values (array for single-axis, Map for multi-axis)\n * @param shouldFilterXAxis - Whether X-axis is being filtered\n * @param isMultiAxis - Whether this is a multi-axis scenario\n */\nexport function updateChannelDomains(channelDomain, filteredDomain, shouldFilterXAxis, isMultiAxis) {\n    if (isMultiAxis && filteredDomain instanceof Map) {\n        filteredDomain.forEach((domain, scaleKey) => {\n            if (domain && Array.isArray(domain) && domain.length > 0) {\n                channelDomain[scaleKey] = domain;\n            }\n        });\n    }\n    else if (!isMultiAxis && Array.isArray(filteredDomain)) {\n        if (filteredDomain.length > 0) {\n            channelDomain[shouldFilterXAxis ? 'x' : 'y'] = filteredDomain;\n        }\n    }\n}\n//# sourceMappingURL=adaptiveFilter.js.map"],"names":["extractSingleAxisScaleInfo","shouldFilterXAxis","scaleX","scaleY","currentScale","targetScale","isSourceDiscrete","isOrdinalScale","isTargetDiscrete","targetOriginalDomain","shouldPreserveZeroBaseline","extractMultiAxisScaleInfo","scale","channelDomain","getAxisScaleDomains","axisType","axisScales","key","targetScaleDomain","targetScaleKeys","targetScales","item","index","getUniqueSortedValues","values","a","b","calculateFilteredDomain","filteredValues","min","max","convertToNumeric","value","filterMarkDataByDomain","markDataPairs","domain","adaptiveMode","isFalsyValue","sourceChannel","targetChannel","allFilteredTargetValues","markData","channelData","sourceValues","targetValues","normalizedSourceValues","isTargetArray2D","dataLength","i","sourceValue","shouldInclude","sourceTime","domainStartTime","domainEndTime","numChannels","channelIdx","targetValue","numericValue","processSingleAxisFiltering","scaleInfo","processMultiAxisViewFiltering","markToScaleMap","filteredDomain","scaleKey","scaleIndex","currentIsTargetDiscrete","currentShouldPreserveZeroBaseline","markFilteredDomain","processMultiAxisMarkFiltering","targetMarkKey","targetScaleKey","relevantMarkData","updateChannelDomains","isMultiAxis"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/g2/esm/interaction/brushAxisHighlight.js

@@ -0,0 +1,227 @@
+import "../../../g/dist/index.esm.js";
+import { subObject as W } from "../utils/helper.js";
+import { domainOf as D } from "../utils/scale.js";
+import { brush as tt } from "./brushHighlight.js";
+import { brushXRegion as et } from "./brushXHighlight.js";
+import { brushYRegion as nt } from "./brushYHighlight.js";
+import { selectPlotArea as st, selectG2Elements as ot, mergeState as rt, createDatumof as it, createValueof as at, useState as ct } from "./utils.js";
+import { Rect as P } from "../../../g-lite/dist/index.esm.js";
+var N = function(e, u) {
+  var h = {};
+  for (var a in e) Object.prototype.hasOwnProperty.call(e, a) && u.indexOf(a) < 0 && (h[a] = e[a]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var c = 0, a = Object.getOwnPropertySymbols(e); c < a.length; c++)
+      u.indexOf(a[c]) < 0 && Object.prototype.propertyIsEnumerable.call(e, a[c]) && (h[a[c]] = e[a[c]]);
+  return h;
+};
+const ft = "axis", lt = "axis-line", mt = "axis-main-group", $ = "axis-hot-area";
+function ut(e) {
+  return e.getElementsByClassName(ft);
+}
+function Z(e) {
+  return e.getElementsByClassName(lt)[0];
+}
+function ht(e) {
+  return e.getElementsByClassName(mt)[0];
+}
+function G(e) {
+  return ht(e).getLocalBounds();
+}
+function dt(e, u) {
+  var { cross: h, offsetX: a, offsetY: c } = u, d = N(u, ["cross", "offsetX", "offsetY"]);
+  const v = G(e), S = Z(e), [_] = S.getLocalBounds().min, [b, y] = v.min, [f, O] = v.max, g = (f - b) * 2;
+  return {
+    brushRegion: nt,
+    hotZone: new P({
+      className: $,
+      style: Object.assign({
+        // If it is not cross, draw brush in both side of axisLine,
+        // otherwise the draw brush within bounds area.
+        width: h ? g / 2 : g,
+        transform: `translate(${(h ? b : _ - g / 2).toFixed(2)}, ${y})`,
+        height: O - y
+      }, d)
+    }),
+    extent: h ? (
+      // If it is cross, the x range is ignored.
+      (p, l, E, A) => [-1 / 0, l, 1 / 0, A]
+    ) : (p, l, E, A) => [
+      Math.floor(b - a),
+      l,
+      Math.ceil(f - a),
+      A
+    ]
+  };
+}
+function gt(e, u) {
+  var { offsetY: h, offsetX: a, cross: c = !1 } = u, d = N(u, ["offsetY", "offsetX", "cross"]);
+  const v = G(e), S = Z(e), [, _] = S.getLocalBounds().min, [b, y] = v.min, [f, O] = v.max, g = O - y;
+  return {
+    brushRegion: et,
+    hotZone: new P({
+      className: $,
+      style: Object.assign({
+        width: f - b,
+        // If it is not cross, draw brush in both side of axisLine,
+        // otherwise the draw brush within bounds area.
+        height: c ? g : g * 2,
+        transform: `translate(${b}, ${c ? y : _ - g})`
+      }, d)
+    }),
+    extent: c ? (
+      // If it is cross, the y range is ignored.
+      (p, l, E, A) => [p, -1 / 0, E, 1 / 0]
+    ) : (p, l, E, A) => [
+      p,
+      Math.floor(y - h),
+      E,
+      Math.ceil(O - h)
+    ]
+  };
+}
+function pt(e, u) {
+  var {
+    axes: h,
+    // given root, return axes
+    elements: a,
+    // given root, return elements
+    points: c,
+    // given shape, return control points
+    horizontal: d,
+    // given axis, return direction
+    datum: v,
+    // given shape, return datum
+    offsetY: S,
+    // offsetY for shape area
+    offsetX: _,
+    // offsetX for shape area
+    reverse: b = !1,
+    state: y = {},
+    emitter: f,
+    coordinate: O
+  } = u, g = N(u, ["axes", "elements", "points", "horizontal", "datum", "offsetY", "offsetX", "reverse", "state", "emitter", "coordinate"]);
+  const p = a(e), l = h(e), E = at(p, v), { setState: A, removeState: k } = ct(y, E), w = /* @__PURE__ */ new Map(), F = W(g, "mask"), T = (t) => Array.from(w.values()).every(([n, s, r, o]) => t.some(([i, m]) => i >= n && i <= r && m >= s && m <= o)), B = l.map((t) => t.attributes.scale), M = (t) => t.length > 2 ? [t[0], t[t.length - 1]] : t, X = /* @__PURE__ */ new Map(), j = () => {
+    X.clear();
+    for (let t = 0; t < l.length; t++) {
+      const n = B[t], { domain: s } = n.getOptions();
+      X.set(t, M(s));
+    }
+  };
+  j();
+  const L = (t, n) => {
+    const s = [];
+    for (const o of p) {
+      const i = c(o);
+      T(i) ? (A(o, "active"), s.push(o)) : A(o, "inactive");
+    }
+    if (X.set(t, q(s, t)), !n)
+      return;
+    const r = () => {
+      if (!R)
+        return Array.from(X.values());
+      const o = [];
+      for (const [i, m] of X) {
+        const x = B[i], { name: I } = x.getOptions();
+        I === "x" ? o[0] = m : o[1] = m;
+      }
+      return o;
+    };
+    f.emit("brushAxis:highlight", {
+      nativeEvent: !0,
+      data: {
+        selection: r()
+      }
+    });
+  }, V = (t) => {
+    for (const n of p)
+      k(n, "active", "inactive");
+    j(), t && f.emit("brushAxis:remove", { nativeEvent: !0 });
+  }, q = (t, n) => {
+    const s = B[n], { name: r } = s.getOptions(), o = t.map((i) => {
+      const m = i.__data__;
+      return s.invert(m[r]);
+    });
+    return M(D(s, o));
+  }, R = l.some(d) && l.some((t) => !d(t)), Y = [];
+  for (let t = 0; t < l.length; t++) {
+    const n = l[t], s = d(n) ? gt : dt, { hotZone: r, brushRegion: o, extent: i } = s(n, {
+      offsetY: S,
+      offsetX: _,
+      cross: R,
+      zIndex: 999,
+      // Pin mask to top.
+      fill: "transparent"
+      // Make it interactive.
+    });
+    n.parentNode.appendChild(r);
+    const m = tt(r, Object.assign(Object.assign({}, F), {
+      reverse: b,
+      brushRegion: o,
+      brushended(x) {
+        w.delete(n), Array.from(w.entries()).length === 0 ? V(x) : L(t, x);
+      },
+      brushed(x, I, K, Q, U) {
+        w.set(n, i(x, I, K, Q)), L(t, U);
+      }
+    }));
+    Y.push(m);
+  }
+  const z = (t = {}) => {
+    const { nativeEvent: n } = t;
+    n || Y.forEach((s) => s.remove(!1));
+  }, J = (t, n, s) => {
+    const [r, o] = t, i = (I) => I.getStep ? I.getStep() : 0, m = C(r, n, s), x = C(o, n, s) + i(n);
+    return d(s) ? [m, -1 / 0, x, 1 / 0] : [-1 / 0, m, 1 / 0, x];
+  }, C = (t, n, s) => {
+    const { height: r, width: o } = O.getOptions(), i = n.clone();
+    return d(s) ? i.update({ range: [0, o] }) : i.update({ range: [r, 0] }), i.map(t);
+  }, H = (t) => {
+    const { nativeEvent: n } = t;
+    if (n)
+      return;
+    const { selection: s } = t.data;
+    for (let r = 0; r < Y.length; r++) {
+      const o = s[r], i = Y[r], m = l[r];
+      if (o) {
+        const x = B[r];
+        i.move(...J(o, x, m), !1);
+      } else
+        i.remove(!1);
+    }
+  };
+  return f.on("brushAxis:remove", z), f.on("brushAxis:highlight", H), () => {
+    Y.forEach((t) => t.destroy()), f.off("brushAxis:remove", z), f.off("brushAxis:highlight", H);
+  };
+}
+function Et(e) {
+  return (u, h, a) => {
+    const { container: c, view: d, options: v } = u, S = st(c), { x: _, y: b } = S.getBBox(), { coordinate: y } = d;
+    return pt(c, Object.assign({
+      elements: ot,
+      axes: ut,
+      offsetY: b,
+      offsetX: _,
+      points: (f) => f.__data__.points,
+      horizontal: (f) => {
+        const { startPos: [O, g], endPos: [p, l] } = f.attributes;
+        return O !== p && g === l;
+      },
+      datum: it(d),
+      state: rt(v, [
+        "active",
+        ["inactive", { opacity: 0.5 }]
+      ]),
+      coordinate: y,
+      emitter: a
+    }, e));
+  };
+}
+export {
+  ft as AXIS_CLASS_NAME,
+  $ as AXIS_HOT_AREA_CLASS_NAME,
+  lt as AXIS_LINE_CLASS_NAME,
+  mt as AXIS_MAIN_CLASS_NAME,
+  Et as BrushAxisHighlight,
+  pt as brushAxisHighlight
+};
+//# sourceMappingURL=brushAxisHighlight.js.map