@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/scale/esm/scales/band.js

@@ -0,0 +1,113 @@
+import { Ordinal as k, defaultUnknown as z } from "./ordinal.js";
+import { InternMap as P } from "../utils/internMap.js";
+function E(t) {
+  const n = t.reduce((e, a) => Math.min(e, a), 1 / 0);
+  return n === 1 / 0 ? [] : t.map((e) => e / n);
+}
+function T(t, n) {
+  const e = t.length, a = n - e;
+  return a > 0 ? [...t, ...new Array(a).fill(1)] : a < 0 ? t.slice(0, n) : t;
+}
+function D(t) {
+  return Math.round(t * 1e12) / 1e12;
+}
+function U(t) {
+  const { domain: n, range: e, paddingOuter: a, paddingInner: c, flex: g, round: s, align: l } = t, d = n.length, S = T(g, d), [i, h] = e, o = h - i, I = 2 / d * a + 1 - 1 / d * c, f = o / I, m = f * c / d, W = f - d * m, p = E(S), M = p.reduce((r, u) => r + u), v = W / M, A = new P(n.map((r, u) => {
+    const x = p[u] * v;
+    return [r, s ? Math.floor(x) : x];
+  })), B = new P(n.map((r, u) => {
+    const y = p[u] * v + m;
+    return [r, s ? Math.floor(y) : y];
+  })), w = Array.from(B.values()).reduce((r, u) => r + u), F = (o - (w - w / d * c)) * l, O = i + F;
+  let b = s ? Math.round(O) : O;
+  const R = new Array(d);
+  for (let r = 0; r < d; r += 1) {
+    R[r] = D(b);
+    const u = n[r];
+    b += B.get(u);
+  }
+  return {
+    valueBandWidth: A,
+    valueStep: B,
+    adjustedRange: R
+  };
+}
+function _(t) {
+  var n;
+  const { domain: e } = t, a = e.length;
+  if (a === 0)
+    return {
+      valueBandWidth: void 0,
+      valueStep: void 0,
+      adjustedRange: []
+    };
+  if (!!(!((n = t.flex) === null || n === void 0) && n.length))
+    return U(t);
+  const { range: g, paddingOuter: s, paddingInner: l, round: d, align: S } = t;
+  let i, h, o = g[0];
+  const f = g[1] - o, m = s * 2, W = a - l;
+  i = f / Math.max(1, m + W), d && (i = Math.floor(i)), o += (f - i * (a - l)) * S, h = i * (1 - l), d && (o = Math.round(o), h = Math.round(h));
+  const p = new Array(a).fill(0).map((M, v) => o + v * i);
+  return {
+    valueStep: i,
+    valueBandWidth: h,
+    adjustedRange: p
+  };
+}
+class j extends k {
+  // 覆盖默认配置
+  getDefaultOptions() {
+    return {
+      domain: [],
+      range: [0, 1],
+      align: 0.5,
+      round: !1,
+      paddingInner: 0,
+      paddingOuter: 0,
+      padding: 0,
+      unknown: z,
+      flex: []
+    };
+  }
+  // 显示指定 options 的类型为 OrdinalOptions，从而推断出 O 的类型
+  constructor(n) {
+    super(n);
+  }
+  clone() {
+    return new j(this.options);
+  }
+  getStep(n) {
+    return this.valueStep === void 0 ? 1 : typeof this.valueStep == "number" ? this.valueStep : n === void 0 ? Array.from(this.valueStep.values())[0] : this.valueStep.get(n);
+  }
+  getBandWidth(n) {
+    return this.valueBandWidth === void 0 ? 1 : typeof this.valueBandWidth == "number" ? this.valueBandWidth : n === void 0 ? Array.from(this.valueBandWidth.values())[0] : this.valueBandWidth.get(n);
+  }
+  getRange() {
+    return this.adjustedRange;
+  }
+  getPaddingInner() {
+    const { padding: n, paddingInner: e } = this.options;
+    return n > 0 ? n : e;
+  }
+  getPaddingOuter() {
+    const { padding: n, paddingOuter: e } = this.options;
+    return n > 0 ? n : e;
+  }
+  rescale() {
+    super.rescale();
+    const { align: n, domain: e, range: a, round: c, flex: g } = this.options, { adjustedRange: s, valueBandWidth: l, valueStep: d } = _({
+      align: n,
+      range: a,
+      round: c,
+      flex: g,
+      paddingInner: this.getPaddingInner(),
+      paddingOuter: this.getPaddingOuter(),
+      domain: e
+    });
+    this.valueStep = d, this.valueBandWidth = l, this.adjustedRange = s;
+  }
+}
+export {
+  j as Band
+};
+//# sourceMappingURL=band.js.map

package/dist/node_modules/@antv/scale/esm/scales/band.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"band.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/band.js"],"sourcesContent":["import { InternMap } from '../utils';\nimport { Ordinal, defaultUnknown } from './ordinal';\nfunction normalize(array) {\n    const min = array.reduce((a, b) => Math.min(a, b), Infinity);\n    return min === Infinity ? [] : array.map((d) => d / min);\n}\nfunction splice(array, n) {\n    const sn = array.length;\n    const diff = n - sn;\n    return diff > 0 ? [...array, ...new Array(diff).fill(1)] : diff < 0 ? array.slice(0, n) : array;\n}\nfunction pretty(n) {\n    return Math.round(n * 1e12) / 1e12;\n}\n/**\n * 基于 band 基础配置获取存在 flex band 的状态\n */\nfunction computeFlexBandState(options) {\n    // 如果 flex 比 domain 少，那么就补全\n    // 如果 flex 比 domain 多，就截取\n    const { domain, range, paddingOuter, paddingInner, flex: F, round, align } = options;\n    const n = domain.length;\n    const flex = splice(F, n);\n    // 根据下面的等式可以计算出所有 step 的总和\n    // stepSum = step1 + step2 ... + stepN;\n    // stepAverage = stepSum / n;\n    // PO = stepAverage * paddingOuter;\n    // PI = stepAverage * paddingInner;\n    // width = PO * 2 + stepSum - PI;\n    const [start, end] = range;\n    const width = end - start;\n    const ratio = (2 / n) * paddingOuter + 1 - (1 / n) * paddingInner;\n    const stepSum = width / ratio;\n    // stepSum = (b1 + PI) + (b2 + PI) ... + (bN + PI)\n    // = bandSum + PI * n;\n    const PI = (stepSum * paddingInner) / n;\n    const bandWidthSum = stepSum - n * PI;\n    // 计算出最小的 bandWidth\n    const normalizedFlex = normalize(flex);\n    const flexSum = normalizedFlex.reduce((sum, value) => sum + value);\n    const minBandWidth = bandWidthSum / flexSum;\n    // 计算每个 bandWidth 和 step，并且用定义域内的值索引\n    const valueBandWidth = new InternMap(domain.map((d, i) => {\n        const bandWidth = normalizedFlex[i] * minBandWidth;\n        return [d, round ? Math.floor(bandWidth) : bandWidth];\n    }));\n    const valueStep = new InternMap(domain.map((d, i) => {\n        const bandWidth = normalizedFlex[i] * minBandWidth;\n        const step = bandWidth + PI;\n        return [d, round ? Math.floor(step) : step];\n    }));\n    // 计算起始位置的偏移量\n    // 因为 step 可能被 round 了，重新计算所有的 step 的总和\n    const finalStepSum = Array.from(valueStep.values()).reduce((sum, value) => sum + value);\n    const outerPaddingSum = width - (finalStepSum - (finalStepSum / n) * paddingInner);\n    const offset = outerPaddingSum * align;\n    // 计算 adjustedRange，也就是 domain 中每个值映射之后的值\n    const bandStart = start + offset;\n    let prev = round ? Math.round(bandStart) : bandStart;\n    const adjustedRange = new Array(n);\n    for (let i = 0; i < n; i += 1) {\n        // 简单处理精度问题\n        adjustedRange[i] = pretty(prev);\n        const value = domain[i];\n        prev += valueStep.get(value);\n    }\n    return {\n        valueBandWidth,\n        valueStep,\n        adjustedRange,\n    };\n}\n/**\n * 基于 band 基础配置获取 band 的状态\n */\nfunction computeBandState(options) {\n    var _a;\n    const { domain } = options;\n    const n = domain.length;\n    if (n === 0) {\n        return {\n            valueBandWidth: undefined,\n            valueStep: undefined,\n            adjustedRange: [],\n        };\n    }\n    const hasFlex = !!((_a = options.flex) === null || _a === void 0 ? void 0 : _a.length);\n    if (hasFlex) {\n        return computeFlexBandState(options);\n    }\n    const { range, paddingOuter, paddingInner, round, align } = options;\n    let step;\n    let bandWidth;\n    let rangeStart = range[0];\n    const rangeEnd = range[1];\n    // range 的计算方式如下：\n    // = stop - start\n    // = (n * step(n 个 step) )\n    // + (2 * step * paddingOuter(两边的 padding))\n    // - (1 * step * paddingInner(多出的一个 inner))\n    const deltaRange = rangeEnd - rangeStart;\n    const outerTotal = paddingOuter * 2;\n    const innerTotal = n - paddingInner;\n    step = deltaRange / Math.max(1, outerTotal + innerTotal);\n    // 优化成整数\n    if (round) {\n        step = Math.floor(step);\n    }\n    // 基于 align 实现偏移\n    rangeStart += (deltaRange - step * (n - paddingInner)) * align;\n    // 一个 step 的组成如下：\n    // step = bandWidth + step * paddingInner，\n    // 则 bandWidth = step - step * (paddingInner)\n    bandWidth = step * (1 - paddingInner);\n    if (round) {\n        rangeStart = Math.round(rangeStart);\n        bandWidth = Math.round(bandWidth);\n    }\n    // 转化后的 range\n    const adjustedRange = new Array(n).fill(0).map((_, i) => rangeStart + i * step);\n    return {\n        valueStep: step,\n        valueBandWidth: bandWidth,\n        adjustedRange,\n    };\n}\n/**\n * Band 比例尺\n *\n * 一种特殊的 ordinal scale，区别在于值域的范围是连续的。\n * 使用的场景例如柱状图，可以用来定位各个柱子水平方向距离原点开始绘制的距离、各柱子之间的间距\n *\n * 由于部分选项较为抽象，见下图描述：\n *\n * BN = bandWidthN\n * SN = stepN\n * domain = [A, B]\n *\n * 约束关系如下\n * width = PO + B1 + PI + B2 + PI ... + BN + PO;\n * PO = (S1 + S2 + ... SN) / N * paddingOuter\n * PI = (S1 + S2 + ... SN) / N * paddingInner\n * BN / BN-1 = flex[n] / flex[n-1]\n *\n * |<------------------------------------------- range ------------------------------------------->|\n * |             |                   |             |                   |             |             |\n * |<-----PO---->|<------B1--------->|<-----PI---->|<-------B2-------->|<----PI----->|<-----PO---->|\n * |             | ***************** |             | ***************** |             |             |\n * |             | ******* A ******* |             | ******* B ******* |             |             |\n * |             | ***************** |             | ***************** |             |             |\n * |             |<--------------S1--------------->| <--------------S2-------------->|                                              |\n * |-----------------------------------------------------------------------------------------------|\n *\n */\nexport class Band extends Ordinal {\n    // 覆盖默认配置\n    getDefaultOptions() {\n        return {\n            domain: [],\n            range: [0, 1],\n            align: 0.5,\n            round: false,\n            paddingInner: 0,\n            paddingOuter: 0,\n            padding: 0,\n            unknown: defaultUnknown,\n            flex: [],\n        };\n    }\n    // 显示指定 options 的类型为 OrdinalOptions，从而推断出 O 的类型\n    constructor(options) {\n        super(options);\n    }\n    clone() {\n        return new Band(this.options);\n    }\n    getStep(x) {\n        if (this.valueStep === undefined)\n            return 1;\n        // 没有 flex 的情况时, valueStep 是 number 类型\n        if (typeof this.valueStep === 'number') {\n            return this.valueStep;\n        }\n        // 对于 flex 都为 1 的情况，x 不是必须要传入的\n        // 这种情况所有的条的 step 都相等，所以返回第一个就好\n        if (x === undefined)\n            return Array.from(this.valueStep.values())[0];\n        return this.valueStep.get(x);\n    }\n    getBandWidth(x) {\n        if (this.valueBandWidth === undefined)\n            return 1;\n        // 没有 flex, valueBandWidth 是 number 类型\n        if (typeof this.valueBandWidth === 'number') {\n            return this.valueBandWidth;\n        }\n        // 对于 flex 都为 1 的情况，x 不是必须要传入的\n        // 这种情况所有的条的 bandWidth 都相等，所以返回第一个\n        if (x === undefined)\n            return Array.from(this.valueBandWidth.values())[0];\n        return this.valueBandWidth.get(x);\n    }\n    getRange() {\n        return this.adjustedRange;\n    }\n    getPaddingInner() {\n        const { padding, paddingInner } = this.options;\n        return padding > 0 ? padding : paddingInner;\n    }\n    getPaddingOuter() {\n        const { padding, paddingOuter } = this.options;\n        return padding > 0 ? padding : paddingOuter;\n    }\n    rescale() {\n        super.rescale();\n        // 当用户配置了opt.padding 且非 0 时，我们覆盖已经设置的 paddingInner paddingOuter\n        // 我们约定 padding 的优先级较 paddingInner 和 paddingOuter 高\n        const { align, domain, range, round, flex } = this.options;\n        const { adjustedRange, valueBandWidth, valueStep } = computeBandState({\n            align,\n            range,\n            round,\n            flex,\n            paddingInner: this.getPaddingInner(),\n            paddingOuter: this.getPaddingOuter(),\n            domain,\n        });\n        // 更新必要的属性\n        this.valueStep = valueStep;\n        this.valueBandWidth = valueBandWidth;\n        this.adjustedRange = adjustedRange;\n    }\n}\n//# sourceMappingURL=band.js.map"],"names":["normalize","array","min","a","b","d","splice","sn","diff","pretty","n","computeFlexBandState","options","domain","range","paddingOuter","paddingInner","F","round","align","flex","start","end","width","ratio","stepSum","PI","bandWidthSum","normalizedFlex","flexSum","sum","value","minBandWidth","valueBandWidth","InternMap","i","bandWidth","valueStep","step","finalStepSum","offset","bandStart","prev","adjustedRange","computeBandState","_a","rangeStart","deltaRange","outerTotal","innerTotal","_","Band","Ordinal","defaultUnknown","x","padding"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/base.js

@@ -0,0 +1,44 @@
+import r from "../../../util/esm/lodash/deep-mix.js";
+class o {
+  /**
+   * 将用户传入的选项和默认选项合并，生成当前比例尺的选项
+   */
+  transformBreaks(s) {
+    return s;
+  }
+  /**
+   * 构造函数，根据自定义的选项和默认选项生成当前选项
+   * @param options 需要自定义配置的选项
+   */
+  constructor(s) {
+    var t;
+    this.options = r({}, this.getDefaultOptions()), this.update(!((t = s == null ? void 0 : s.breaks) === null || t === void 0) && t.length ? this.transformBreaks(s) : s);
+  }
+  /**
+   * 返回当前的所有选项
+   * @returns 当前的所有选项
+   */
+  getOptions() {
+    return this.options;
+  }
+  /**
+   * 更新选项和比例尺的内部状态
+   * @param updateOptions 需要更新的选项
+   */
+  update(s = {}) {
+    const t = s.breaks ? this.transformBreaks(s) : s;
+    this.options = r({}, this.options, t), this.rescale(t);
+  }
+  /**
+   * 根据需要更新 options 和更新后的 options 更新 scale 的内部状态，
+   * 在函数内部可以用 this.options 获得更新后的 options
+   * @param options 需要更新的 options
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  rescale(s) {
+  }
+}
+export {
+  o as Base
+};
+//# sourceMappingURL=base.js.map

package/dist/node_modules/@antv/scale/esm/scales/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/base.js"],"sourcesContent":["import { deepMix } from '@antv/util';\nexport class Base {\n    /**\n     * 将用户传入的选项和默认选项合并，生成当前比例尺的选项\n     */\n    transformBreaks(options) {\n        return options;\n    }\n    /**\n     * 构造函数，根据自定义的选项和默认选项生成当前选项\n     * @param options 需要自定义配置的选项\n     */\n    constructor(options) {\n        var _a;\n        this.options = deepMix({}, this.getDefaultOptions());\n        this.update(((_a = options === null || options === void 0 ? void 0 : options.breaks) === null || _a === void 0 ? void 0 : _a.length) ? this.transformBreaks(options) : options);\n    }\n    /**\n     * 返回当前的所有选项\n     * @returns 当前的所有选项\n     */\n    getOptions() {\n        return this.options;\n    }\n    /**\n     * 更新选项和比例尺的内部状态\n     * @param updateOptions 需要更新的选项\n     */\n    update(updateOptions = {}) {\n        const options = updateOptions.breaks ? this.transformBreaks(updateOptions) : updateOptions;\n        this.options = deepMix({}, this.options, options);\n        this.rescale(options);\n    }\n    /**\n     * 根据需要更新 options 和更新后的 options 更新 scale 的内部状态，\n     * 在函数内部可以用 this.options 获得更新后的 options\n     * @param options 需要更新的 options\n     */\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    rescale(options) { }\n}\n//# sourceMappingURL=base.js.map"],"names":["Base","options","_a","deepMix","updateOptions"],"mappings":";AACO,MAAMA,EAAK;AAAA;AAAA;AAAA;AAAA,EAId,gBAAgBC,GAAS;AACrB,WAAOA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,YAAYA,GAAS;AACjB,QAAIC;AACJ,SAAK,UAAUC,EAAQ,CAAA,GAAI,KAAK,kBAAiB,CAAE,GACnD,KAAK,OAAS,GAAAD,IAAKD,KAAY,OAA6B,SAASA,EAAQ,YAAY,QAAQC,MAAO,WAAkBA,EAAG,SAAU,KAAK,gBAAgBD,CAAO,IAAIA,CAAO;AAAA,EAClL;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,aAAa;AACT,WAAO,KAAK;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,OAAOG,IAAgB,IAAI;AACvB,UAAMH,IAAUG,EAAc,SAAS,KAAK,gBAAgBA,CAAa,IAAIA;AAC7E,SAAK,UAAUD,EAAQ,CAAA,GAAI,KAAK,SAASF,CAAO,GAChD,KAAK,QAAQA,CAAO;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAQA,GAAS;AAAA,EAAE;AACvB;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/constant.js

@@ -0,0 +1,52 @@
+import { d3Ticks as u } from "../tick-methods/d3-ticks.js";
+import { Base as d } from "./base.js";
+import e from "../../../util/esm/lodash/is-number.js";
+class r extends d {
+  /**
+   * 返回需要覆盖的默认选项
+   * @returns 需要覆盖的默认选项
+   */
+  getDefaultOptions() {
+    return {
+      range: [0],
+      domain: [0, 1],
+      unknown: void 0,
+      tickCount: 5,
+      tickMethod: u
+    };
+  }
+  /**
+   * 输入和输出满足：y = b，其中 b 是一个常量，是 options.range 的第一个元素
+   * @param _ 输入值
+   * @returns 输出值（常量）
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(t) {
+    const [n] = this.options.range;
+    return n !== void 0 ? n : this.options.unknown;
+  }
+  /**
+   * 如果 x 是该比例尺的常量（x === b），返回输入值的范围（即定义域），否者返回 []
+   * @param x 输出值 (常量）
+   * @returns 定义域
+   */
+  invert(t) {
+    const [n] = this.options.range;
+    return t === n && n !== void 0 ? this.options.domain : [];
+  }
+  getTicks() {
+    const { tickMethod: t, domain: n, tickCount: s } = this.options, [o, i] = n;
+    return !e(o) || !e(i) ? [] : t(o, i, s);
+  }
+  /**
+   * 克隆 Constant Scale
+   * @returns 拥有相同选项且独立的 Constant Scale
+   */
+  clone() {
+    return new r(this.options);
+  }
+}
+export {
+  r as Constant
+};
+//# sourceMappingURL=constant.js.map

package/dist/node_modules/@antv/scale/esm/scales/constant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/constant.js"],"sourcesContent":["import { isNumber } from '@antv/util';\nimport { d3Ticks } from '../tick-methods/d3-ticks';\nimport { Base } from './base';\nexport class Constant extends Base {\n    /**\n     * 返回需要覆盖的默认选项\n     * @returns 需要覆盖的默认选项\n     */\n    getDefaultOptions() {\n        return {\n            range: [0],\n            domain: [0, 1],\n            unknown: undefined,\n            tickCount: 5,\n            tickMethod: d3Ticks,\n        };\n    }\n    /**\n     * 输入和输出满足：y = b，其中 b 是一个常量，是 options.range 的第一个元素\n     * @param _ 输入值\n     * @returns 输出值（常量）\n     */\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    map(_) {\n        const [v] = this.options.range;\n        return v !== undefined ? v : this.options.unknown;\n    }\n    /**\n     * 如果 x 是该比例尺的常量（\bx === b），返回输入值的范围（即定义域），否者返回 []\n     * @param x 输出值 (常量）\n     * @returns 定义域\n     */\n    invert(x) {\n        const [v] = this.options.range;\n        return x === v && v !== undefined ? this.options.domain : [];\n    }\n    getTicks() {\n        const { tickMethod, domain, tickCount } = this.options;\n        const [a, b] = domain;\n        if (!isNumber(a) || !isNumber(b))\n            return [];\n        return tickMethod(a, b, tickCount);\n    }\n    /**\n     * 克隆 Constant Scale\n     * @returns 拥有相同选项且独立的 Constant Scale\n     */\n    clone() {\n        return new Constant(this.options);\n    }\n}\n//# sourceMappingURL=constant.js.map"],"names":["Constant","Base","d3Ticks","_","v","x","tickMethod","domain","tickCount","a","b","isNumber"],"mappings":";;;AAGO,MAAMA,UAAiBC,EAAK;AAAA;AAAA;AAAA;AAAA;AAAA,EAK/B,oBAAoB;AAChB,WAAO;AAAA,MACH,OAAO,CAAC,CAAC;AAAA,MACT,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,SAAS;AAAA,MACT,WAAW;AAAA,MACX,YAAYC;AAAA,IACxB;AAAA,EACI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAIC,GAAG;AACH,UAAM,CAACC,CAAC,IAAI,KAAK,QAAQ;AACzB,WAAOA,MAAM,SAAYA,IAAI,KAAK,QAAQ;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAOC,GAAG;AACN,UAAM,CAACD,CAAC,IAAI,KAAK,QAAQ;AACzB,WAAOC,MAAMD,KAAKA,MAAM,SAAY,KAAK,QAAQ,SAAS,CAAA;AAAA,EAC9D;AAAA,EACA,WAAW;AACP,UAAM,EAAE,YAAAE,GAAY,QAAAC,GAAQ,WAAAC,EAAS,IAAK,KAAK,SACzC,CAACC,GAAGC,CAAC,IAAIH;AACf,WAAI,CAACI,EAASF,CAAC,KAAK,CAACE,EAASD,CAAC,IACpB,CAAA,IACJJ,EAAWG,GAAGC,GAAGF,CAAS;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQ;AACJ,WAAO,IAAIR,EAAS,KAAK,OAAO;AAAA,EACpC;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/continuous.js

@@ -0,0 +1,86 @@
+import { Base as C } from "./base.js";
+import { createInterpolateNumber as l, createInterpolateRound as w } from "../utils/interpolate.js";
+import { isValid as f } from "../utils/is-valid.js";
+import M from "../../../util/esm/lodash/is-array.js";
+import { d3LinearNice as O } from "../utils/d3-linear-nice.js";
+import y from "../../../util/esm/lodash/identity.js";
+import { createClamp as I } from "../utils/clamp.js";
+import { compose as m } from "../utils/compose.js";
+import { createNormalize as h } from "../utils/normalize.js";
+import { bisect as N } from "../utils/bisect.js";
+const T = (i, t, o) => {
+  const [e, n] = i, [s, c] = t;
+  let p, a;
+  return e < n ? (p = h(e, n), a = o(s, c)) : (p = h(n, e), a = o(c, s)), m(a, p);
+}, v = (i, t, o) => {
+  const e = Math.min(i.length, t.length) - 1, n = new Array(e), s = new Array(e), c = i[0] > i[e], p = c ? [...i].reverse() : i, a = c ? [...t].reverse() : t;
+  for (let r = 0; r < e; r += 1)
+    n[r] = h(p[r], p[r + 1]), s[r] = o(a[r], a[r + 1]);
+  return (r) => {
+    const u = N(i, r, 1, e) - 1, g = n[u], k = s[u];
+    return m(k, g)(r);
+  };
+}, d = (i, t, o, e) => (Math.min(i.length, t.length) > 2 ? v : T)(i, t, e ? w : o);
+class j extends C {
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      range: [0, 1],
+      nice: !1,
+      clamp: !1,
+      round: !1,
+      interpolate: l,
+      tickCount: 5
+    };
+  }
+  /**
+   * y = interpolate(normalize(clamp(transform(x))))
+   */
+  map(t) {
+    return f(t) ? this.output(t) : this.options.unknown;
+  }
+  /**
+   * x = transform(clamp(interpolate(normalize(y))))
+   */
+  invert(t) {
+    return f(t) ? this.input(t) : this.options.unknown;
+  }
+  nice() {
+    if (!this.options.nice || M(this.options.breaks))
+      return;
+    const [t, o, e, ...n] = this.getTickMethodOptions();
+    this.options.domain = this.chooseNice()(t, o, e, ...n);
+  }
+  getTicks() {
+    const { tickMethod: t } = this.options, [o, e, n, ...s] = this.getTickMethodOptions();
+    return t(o, e, n, ...s);
+  }
+  getTickMethodOptions() {
+    const { domain: t, tickCount: o } = this.options, e = t[0], n = t[t.length - 1];
+    return [e, n, o];
+  }
+  chooseNice() {
+    return O;
+  }
+  rescale() {
+    this.nice();
+    const [t, o] = this.chooseTransforms();
+    this.composeOutput(t, this.chooseClamp(t)), this.composeInput(t, o, this.chooseClamp(o));
+  }
+  chooseClamp(t) {
+    const { clamp: o, range: e } = this.options, n = this.options.domain.map(t), s = Math.min(n.length, e.length);
+    return o ? I(n[0], n[s - 1]) : y;
+  }
+  composeOutput(t, o) {
+    const { domain: e, range: n, round: s, interpolate: c } = this.options, p = d(e.map(t), n, c, s);
+    this.output = m(p, o, t);
+  }
+  composeInput(t, o, e) {
+    const { domain: n, range: s } = this.options, c = d(s, n.map(t), l);
+    this.input = m(o, e, c);
+  }
+}
+export {
+  j as Continuous
+};
+//# sourceMappingURL=continuous.js.map

package/dist/node_modules/@antv/scale/esm/scales/continuous.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuous.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/continuous.js"],"sourcesContent":["import { identity, isArray } from '@antv/util';\nimport { Base } from './base';\nimport { createInterpolateNumber, createInterpolateRound, createClamp, createNormalize, bisect, compose, d3LinearNice, isValid, } from '../utils';\n/** 当 domain 和 range 只有一段的时候的 map 的 工厂函数 */\nconst createBiMap = (domain, range, createInterpolate) => {\n    const [d0, d1] = domain;\n    const [r0, r1] = range;\n    let normalize;\n    let interpolate;\n    if (d0 < d1) {\n        normalize = createNormalize(d0, d1);\n        interpolate = createInterpolate(r0, r1);\n    }\n    else {\n        normalize = createNormalize(d1, d0);\n        interpolate = createInterpolate(r1, r0);\n    }\n    return compose(interpolate, normalize);\n};\n/** 当 domain 和 range 有多段时候的 map 的 工厂函数 */\nconst createPolyMap = (domain, range, createInterpolate) => {\n    const len = Math.min(domain.length, range.length) - 1;\n    const normalizeList = new Array(len);\n    const interpolateList = new Array(len);\n    const reverse = domain[0] > domain[len];\n    const ascendingDomain = reverse ? [...domain].reverse() : domain;\n    const ascendingRange = reverse ? [...range].reverse() : range;\n    // 每一段都生成 normalize 和 interpolate\n    for (let i = 0; i < len; i += 1) {\n        normalizeList[i] = createNormalize(ascendingDomain[i], ascendingDomain[i + 1]);\n        interpolateList[i] = createInterpolate(ascendingRange[i], ascendingRange[i + 1]);\n    }\n    // 二分最右查找到相应的 normalize 和 interpolate\n    return (x) => {\n        const i = bisect(domain, x, 1, len) - 1;\n        const normalize = normalizeList[i];\n        const interpolate = interpolateList[i];\n        return compose(interpolate, normalize)(x);\n    };\n};\n/** 选择一个分段映射的函数 */\nconst choosePiecewise = (domain, range, interpolate, shouldRound) => {\n    const n = Math.min(domain.length, range.length);\n    const createPiecewise = n > 2 ? createPolyMap : createBiMap;\n    const createInterpolate = shouldRound ? createInterpolateRound : interpolate;\n    return createPiecewise(domain, range, createInterpolate);\n};\n/**\n * Continuous 比例尺 的输入 x 和输出 y 满足：y = a * f(x) + b\n * 通过函数柯里化和复合函数可以在映射过程中去掉分支，提高性能。\n * 参考：https://github.com/d3/d3-scale/blob/master/src/continuous.js\n */\nexport class Continuous extends Base {\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            range: [0, 1],\n            nice: false,\n            clamp: false,\n            round: false,\n            interpolate: createInterpolateNumber,\n            tickCount: 5,\n        };\n    }\n    /**\n     * y = interpolate(normalize(clamp(transform(x))))\n     */\n    map(x) {\n        if (!isValid(x))\n            return this.options.unknown;\n        return this.output(x);\n    }\n    /**\n     * x = transform(clamp(interpolate(normalize(y))))\n     */\n    invert(x) {\n        if (!isValid(x))\n            return this.options.unknown;\n        return this.input(x);\n    }\n    nice() {\n        if (!this.options.nice || isArray(this.options.breaks))\n            return;\n        const [min, max, tickCount, ...rest] = this.getTickMethodOptions();\n        this.options.domain = this.chooseNice()(min, max, tickCount, ...rest);\n    }\n    getTicks() {\n        const { tickMethod } = this.options;\n        const [min, max, tickCount, ...rest] = this.getTickMethodOptions();\n        return tickMethod(min, max, tickCount, ...rest);\n    }\n    getTickMethodOptions() {\n        const { domain, tickCount } = this.options;\n        const min = domain[0];\n        const max = domain[domain.length - 1];\n        return [min, max, tickCount];\n    }\n    chooseNice() {\n        return d3LinearNice;\n    }\n    rescale() {\n        this.nice();\n        const [transform, untransform] = this.chooseTransforms();\n        this.composeOutput(transform, this.chooseClamp(transform));\n        this.composeInput(transform, untransform, this.chooseClamp(untransform));\n    }\n    chooseClamp(transform) {\n        const { clamp: shouldClamp, range } = this.options;\n        const domain = this.options.domain.map(transform);\n        const n = Math.min(domain.length, range.length);\n        return shouldClamp ? createClamp(domain[0], domain[n - 1]) : identity;\n    }\n    composeOutput(transform, clamp) {\n        const { domain, range, round, interpolate } = this.options;\n        const piecewise = choosePiecewise(domain.map(transform), range, interpolate, round);\n        this.output = compose(piecewise, clamp, transform);\n    }\n    composeInput(transform, untransform, clamp) {\n        const { domain, range } = this.options;\n        const piecewise = choosePiecewise(range, domain.map(transform), createInterpolateNumber);\n        this.input = compose(untransform, clamp, piecewise);\n    }\n}\n//# sourceMappingURL=continuous.js.map"],"names":["createBiMap","domain","range","createInterpolate","d0","d1","r0","r1","normalize","interpolate","createNormalize","compose","createPolyMap","len","normalizeList","interpolateList","reverse","ascendingDomain","ascendingRange","i","x","bisect","choosePiecewise","shouldRound","createInterpolateRound","Continuous","Base","createInterpolateNumber","isValid","isArray","min","max","tickCount","rest","tickMethod","d3LinearNice","transform","untransform","shouldClamp","n","createClamp","identity","clamp","round","piecewise"],"mappings":";;;;;;;;;;AAIA,MAAMA,IAAc,CAACC,GAAQC,GAAOC,MAAsB;AACtD,QAAM,CAACC,GAAIC,CAAE,IAAIJ,GACX,CAACK,GAAIC,CAAE,IAAIL;AACjB,MAAIM,GACAC;AACJ,SAAIL,IAAKC,KACLG,IAAYE,EAAgBN,GAAIC,CAAE,GAClCI,IAAcN,EAAkBG,GAAIC,CAAE,MAGtCC,IAAYE,EAAgBL,GAAID,CAAE,GAClCK,IAAcN,EAAkBI,GAAID,CAAE,IAEnCK,EAAQF,GAAaD,CAAS;AACzC,GAEMI,IAAgB,CAACX,GAAQC,GAAOC,MAAsB;AACxD,QAAMU,IAAM,KAAK,IAAIZ,EAAO,QAAQC,EAAM,MAAM,IAAI,GAC9CY,IAAgB,IAAI,MAAMD,CAAG,GAC7BE,IAAkB,IAAI,MAAMF,CAAG,GAC/BG,IAAUf,EAAO,CAAC,IAAIA,EAAOY,CAAG,GAChCI,IAAkBD,IAAU,CAAC,GAAGf,CAAM,EAAE,QAAO,IAAKA,GACpDiB,IAAiBF,IAAU,CAAC,GAAGd,CAAK,EAAE,QAAO,IAAKA;AAExD,WAASiB,IAAI,GAAGA,IAAIN,GAAKM,KAAK;AAC1B,IAAAL,EAAcK,CAAC,IAAIT,EAAgBO,EAAgBE,CAAC,GAAGF,EAAgBE,IAAI,CAAC,CAAC,GAC7EJ,EAAgBI,CAAC,IAAIhB,EAAkBe,EAAeC,CAAC,GAAGD,EAAeC,IAAI,CAAC,CAAC;AAGnF,SAAO,CAACC,MAAM;AACV,UAAMD,IAAIE,EAAOpB,GAAQmB,GAAG,GAAGP,CAAG,IAAI,GAChCL,IAAYM,EAAcK,CAAC,GAC3BV,IAAcM,EAAgBI,CAAC;AACrC,WAAOR,EAAQF,GAAaD,CAAS,EAAEY,CAAC;AAAA,EAC5C;AACJ,GAEME,IAAkB,CAACrB,GAAQC,GAAOO,GAAac,OACvC,KAAK,IAAItB,EAAO,QAAQC,EAAM,MAAM,IAClB,IAAIU,IAAgBZ,GAEzBC,GAAQC,GADLqB,IAAcC,IAAyBf,CACV;AAOpD,MAAMgB,UAAmBC,EAAK;AAAA,EACjC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO;AAAA,MACP,aAAaC;AAAA,MACb,WAAW;AAAA,IACvB;AAAA,EACI;AAAA;AAAA;AAAA;AAAA,EAIA,IAAIP,GAAG;AACH,WAAKQ,EAAQR,CAAC,IAEP,KAAK,OAAOA,CAAC,IADT,KAAK,QAAQ;AAAA,EAE5B;AAAA;AAAA;AAAA;AAAA,EAIA,OAAOA,GAAG;AACN,WAAKQ,EAAQR,CAAC,IAEP,KAAK,MAAMA,CAAC,IADR,KAAK,QAAQ;AAAA,EAE5B;AAAA,EACA,OAAO;AACH,QAAI,CAAC,KAAK,QAAQ,QAAQS,EAAQ,KAAK,QAAQ,MAAM;AACjD;AACJ,UAAM,CAACC,GAAKC,GAAKC,GAAW,GAAGC,CAAI,IAAI,KAAK,qBAAoB;AAChE,SAAK,QAAQ,SAAS,KAAK,aAAaH,GAAKC,GAAKC,GAAW,GAAGC,CAAI;AAAA,EACxE;AAAA,EACA,WAAW;AACP,UAAM,EAAE,YAAAC,MAAe,KAAK,SACtB,CAACJ,GAAKC,GAAKC,GAAW,GAAGC,CAAI,IAAI,KAAK,qBAAoB;AAChE,WAAOC,EAAWJ,GAAKC,GAAKC,GAAW,GAAGC,CAAI;AAAA,EAClD;AAAA,EACA,uBAAuB;AACnB,UAAM,EAAE,QAAAhC,GAAQ,WAAA+B,EAAS,IAAK,KAAK,SAC7BF,IAAM7B,EAAO,CAAC,GACd8B,IAAM9B,EAAOA,EAAO,SAAS,CAAC;AACpC,WAAO,CAAC6B,GAAKC,GAAKC,CAAS;AAAA,EAC/B;AAAA,EACA,aAAa;AACT,WAAOG;AAAA,EACX;AAAA,EACA,UAAU;AACN,SAAK,KAAI;AACT,UAAM,CAACC,GAAWC,CAAW,IAAI,KAAK,iBAAgB;AACtD,SAAK,cAAcD,GAAW,KAAK,YAAYA,CAAS,CAAC,GACzD,KAAK,aAAaA,GAAWC,GAAa,KAAK,YAAYA,CAAW,CAAC;AAAA,EAC3E;AAAA,EACA,YAAYD,GAAW;AACnB,UAAM,EAAE,OAAOE,GAAa,OAAApC,EAAK,IAAK,KAAK,SACrCD,IAAS,KAAK,QAAQ,OAAO,IAAImC,CAAS,GAC1CG,IAAI,KAAK,IAAItC,EAAO,QAAQC,EAAM,MAAM;AAC9C,WAAOoC,IAAcE,EAAYvC,EAAO,CAAC,GAAGA,EAAOsC,IAAI,CAAC,CAAC,IAAIE;AAAA,EACjE;AAAA,EACA,cAAcL,GAAWM,GAAO;AAC5B,UAAM,EAAE,QAAAzC,GAAQ,OAAAC,GAAO,OAAAyC,GAAO,aAAAlC,EAAW,IAAK,KAAK,SAC7CmC,IAAYtB,EAAgBrB,EAAO,IAAImC,CAAS,GAAGlC,GAAOO,GAAakC,CAAK;AAClF,SAAK,SAAShC,EAAQiC,GAAWF,GAAON,CAAS;AAAA,EACrD;AAAA,EACA,aAAaA,GAAWC,GAAaK,GAAO;AACxC,UAAM,EAAE,QAAAzC,GAAQ,OAAAC,EAAK,IAAK,KAAK,SACzB0C,IAAYtB,EAAgBpB,GAAOD,EAAO,IAAImC,CAAS,GAAGT,CAAuB;AACvF,SAAK,QAAQhB,EAAQ0B,GAAaK,GAAOE,CAAS;AAAA,EACtD;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/identity.js

@@ -0,0 +1,54 @@
+import { Base as m } from "./base.js";
+import { wilkinsonExtended as u } from "../tick-methods/wilkinson-extended.js";
+import { isValid as p } from "../utils/is-valid.js";
+import o from "../../../util/esm/lodash/is-number.js";
+class e extends m {
+  /**
+   * 返回需要覆盖的默认选项
+   * @returns 需要覆盖的默认选项
+   */
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      range: [0, 1],
+      tickCount: 5,
+      unknown: void 0,
+      tickMethod: u
+    };
+  }
+  /**
+   * 输入和输出满足：y = x
+   * @param x 输入值
+   * @returns 输出值
+   */
+  map(t) {
+    return p(t) ? t : this.options.unknown;
+  }
+  /**
+   * map 的逆运算：x = y，在这里和 map 是相同方法
+   * @param x 输出值
+   * @returns 输入值
+   */
+  invert(t) {
+    return this.map(t);
+  }
+  /**
+   * 克隆 Identity Scale
+   * @returns 拥有相同选项且独立的 Identity Scale
+   */
+  clone() {
+    return new e(this.options);
+  }
+  /**
+   * 根据比例尺的配置去生成 ticks，该 ticks 主要用于生成坐标轴
+   * @returns 返回一个 ticks 的数组
+   */
+  getTicks() {
+    const { domain: t, tickCount: r, tickMethod: s } = this.options, [n, i] = t;
+    return !o(n) || !o(i) ? [] : s(n, i, r);
+  }
+}
+export {
+  e as Identity
+};
+//# sourceMappingURL=identity.js.map

package/dist/node_modules/@antv/scale/esm/scales/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/identity.js"],"sourcesContent":["import { isNumber } from '@antv/util';\nimport { Base } from './base';\nimport { wilkinsonExtended } from '../tick-methods/wilkinson-extended';\nimport { isValid } from '../utils';\nexport class Identity extends Base {\n    /**\n     * 返回需要覆盖的默认选项\n     * @returns 需要覆盖的默认选项\n     */\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            range: [0, 1],\n            tickCount: 5,\n            unknown: undefined,\n            tickMethod: wilkinsonExtended,\n        };\n    }\n    /**\n     * 输入和输出满足：y = x\n     * @param x 输入值\n     * @returns 输出值\n     */\n    map(x) {\n        return isValid(x) ? x : this.options.unknown;\n    }\n    /**\n     * map 的逆运算：x = y，在这里和 map 是相同方法\n     * @param x 输出值\n     * @returns 输入值\n     */\n    invert(x) {\n        return this.map(x);\n    }\n    /**\n     * 克隆 Identity Scale\n     * @returns 拥有相同选项且独立的 Identity Scale\n     */\n    clone() {\n        return new Identity(this.options);\n    }\n    /**\n     * 根据比例尺的配置去生成 ticks，该 ticks 主要用于生成坐标轴\n     * @returns 返回一个 ticks 的数组\n     */\n    getTicks() {\n        const { domain, tickCount, tickMethod } = this.options;\n        const [min, max] = domain;\n        if (!isNumber(min) || !isNumber(max))\n            return [];\n        return tickMethod(min, max, tickCount);\n    }\n}\n//# sourceMappingURL=identity.js.map"],"names":["Identity","Base","wilkinsonExtended","x","isValid","domain","tickCount","tickMethod","min","max","isNumber"],"mappings":";;;;AAIO,MAAMA,UAAiBC,EAAK;AAAA;AAAA;AAAA;AAAA;AAAA,EAK/B,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,CAAC;AAAA,MACb,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,WAAW;AAAA,MACX,SAAS;AAAA,MACT,YAAYC;AAAA,IACxB;AAAA,EACI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAIC,GAAG;AACH,WAAOC,EAAQD,CAAC,IAAIA,IAAI,KAAK,QAAQ;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAOA,GAAG;AACN,WAAO,KAAK,IAAIA,CAAC;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQ;AACJ,WAAO,IAAIH,EAAS,KAAK,OAAO;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW;AACP,UAAM,EAAE,QAAAK,GAAQ,WAAAC,GAAW,YAAAC,EAAU,IAAK,KAAK,SACzC,CAACC,GAAKC,CAAG,IAAIJ;AACnB,WAAI,CAACK,EAASF,CAAG,KAAK,CAACE,EAASD,CAAG,IACxB,CAAA,IACJF,EAAWC,GAAKC,GAAKH,CAAS;AAAA,EACzC;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/linear.js

@@ -0,0 +1,83 @@
+import { Continuous as P } from "./continuous.js";
+import { d3Ticks as O } from "../tick-methods/d3-ticks.js";
+import { d3LinearNice as S } from "../utils/d3-linear-nice.js";
+import { createInterpolateValue as W } from "../utils/interpolate.js";
+import I from "../../../util/esm/lodash/last.js";
+import X from "../../../util/esm/lodash/is-array.js";
+import U from "../../../util/esm/lodash/identity.js";
+class w extends P {
+  getDefaultOptions() {
+    return {
+      domain: [0, 1],
+      range: [0, 1],
+      unknown: void 0,
+      nice: !1,
+      clamp: !1,
+      round: !1,
+      interpolate: W,
+      tickMethod: O,
+      tickCount: 5
+    };
+  }
+  removeUnsortedValues(r, o, d) {
+    let t = -1 / 0;
+    return o.reduce((n, i, s) => {
+      if (s === 0)
+        return n;
+      const m = t > 0 ? t : i;
+      return t > 0 && (d ? i > t : i < t) ? n.push(s) : (m - o[s - 1]) * (d ? -1 : 1) < 0 ? (t < 0 && (t = o[s - 1]), n.push(s)) : t = -1 / 0, n;
+    }, []).slice().reverse().forEach((n) => {
+      r.splice(n, 1), o.splice(n, 1);
+    }), { breaksDomain: r, breaksRange: o };
+  }
+  transformDomain(r) {
+    const o = [0.2, 0.8], d = 0.03, { domain: t = [], range: u = [1, 0], breaks: n = [], tickCount: i = 5, nice: s } = r, [m, D] = [Math.min(...t), Math.max(...t)];
+    let E = m, N = D;
+    if (s && n.length < 2) {
+      const e = this.chooseNice()(m, D, i);
+      E = e[0], N = e[e.length - 1];
+    }
+    const A = Math.min(E, m);
+    let h = Math.max(N, D);
+    const T = n.filter(({ end: e }) => e < h).sort((e, k) => e.start - k.start), a = O(A, h, i, T);
+    if (I(a) < h) {
+      const e = S(0, h - I(a), 3);
+      a.push(I(a) + I(e)), h = I(a);
+    }
+    const [b, C] = [u[0], I(u)], F = h - A, V = Math.abs(C - b), g = b > C, l = a.map((e) => {
+      const k = (e - A) / F;
+      return g ? b - k * V : b + k * V;
+    }), [p, M] = o;
+    return T.forEach(({ start: e, end: k, gap: G = d, compress: L = "middle" }) => {
+      const y = a.indexOf(e), B = a.indexOf(k);
+      let x = (l[y] + l[B]) / 2;
+      L === "start" && (x = l[y]), L === "end" && (x = l[B]);
+      const v = G * V / 2;
+      let f = g ? x + v : x - v, c = g ? x - v : x + v;
+      f < p && (c += p - f, f = p), c > M && (f -= c - M, c = M), f > M && (c -= f - M, f = M), c < p && (f += p - c, c = p), l[y] = f, l[B] = c;
+    }), this.removeUnsortedValues(a, l, g);
+  }
+  transformBreaks(r) {
+    const { domain: o, breaks: d = [] } = r;
+    if (!X(r.breaks))
+      return r;
+    const t = Math.max(...o), u = d.filter(({ end: m }) => m < t), n = { ...r, breaks: u }, { breaksDomain: i, breaksRange: s } = this.transformDomain(n);
+    return {
+      ...r,
+      domain: i,
+      range: s,
+      breaks: u,
+      tickMethod: () => [...i]
+    };
+  }
+  chooseTransforms() {
+    return [U, U];
+  }
+  clone() {
+    return new w(this.options);
+  }
+}
+export {
+  w as Linear
+};
+//# sourceMappingURL=linear.js.map

package/dist/node_modules/@antv/scale/esm/scales/linear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/linear.js"],"sourcesContent":["import { identity, isArray, last } from '@antv/util';\nimport { Continuous } from './continuous';\nimport { createInterpolateValue } from '../utils';\nimport { d3Ticks } from '../tick-methods/d3-ticks';\nimport { d3LinearNice } from '../utils/d3-linear-nice';\n/**\n * Linear 比例尺\n *\n * 构造可创建一个在输入和输出之间具有线性关系的比例尺\n */\nexport class Linear extends Continuous {\n    getDefaultOptions() {\n        return {\n            domain: [0, 1],\n            range: [0, 1],\n            unknown: undefined,\n            nice: false,\n            clamp: false,\n            round: false,\n            interpolate: createInterpolateValue,\n            tickMethod: d3Ticks,\n            tickCount: 5,\n        };\n    }\n    removeUnsortedValues(breaksDomain, breaksRange, reverse) {\n        let pre = -Infinity;\n        const deleteIndices = breaksRange.reduce((acc, current, i) => {\n            if (i === 0)\n                return acc;\n            const value = pre > 0 ? pre : current;\n            if (pre > 0 && (reverse ? current > pre : current < pre)) {\n                acc.push(i);\n            }\n            else {\n                const diff = (value - breaksRange[i - 1]) * (reverse ? -1 : 1);\n                if (diff < 0) {\n                    if (pre < 0)\n                        pre = breaksRange[i - 1];\n                    acc.push(i);\n                }\n                else {\n                    pre = -Infinity;\n                }\n            }\n            return acc;\n        }, []);\n        deleteIndices\n            .slice()\n            .reverse()\n            .forEach((index) => {\n            breaksDomain.splice(index, 1);\n            breaksRange.splice(index, 1);\n        });\n        return { breaksDomain, breaksRange };\n    }\n    transformDomain(options) {\n        const RANGE_LIMIT = [0.2, 0.8];\n        const DEFAULT_GAP = 0.03;\n        const { domain = [], range = [1, 0], breaks = [], tickCount = 5, nice } = options;\n        const [min, max] = [Math.min(...domain), Math.max(...domain)];\n        let niceDomainMin = min;\n        let niceDomainMax = max;\n        if (nice && breaks.length < 2) {\n            const niceDomain = this.chooseNice()(min, max, tickCount);\n            niceDomainMin = niceDomain[0];\n            niceDomainMax = niceDomain[niceDomain.length - 1];\n        }\n        const domainMin = Math.min(niceDomainMin, min);\n        let domainMax = Math.max(niceDomainMax, max);\n        const sortedBreaks = breaks.filter(({ end }) => end < domainMax).sort((a, b) => a.start - b.start);\n        const breaksDomain = d3Ticks(domainMin, domainMax, tickCount, sortedBreaks);\n        if (last(breaksDomain) < domainMax) {\n            const nicest = d3LinearNice(0, domainMax - last(breaksDomain), 3);\n            breaksDomain.push(last(breaksDomain) + last(nicest));\n            domainMax = last(breaksDomain);\n        }\n        const [r0, r1] = [range[0], last(range)];\n        const diffDomain = domainMax - domainMin;\n        const diffRange = Math.abs(r1 - r0);\n        const reverse = r0 > r1;\n        // Calculate the new range based on breaks.\n        const breaksRange = breaksDomain.map((d) => {\n            const ratio = (d - domainMin) / diffDomain;\n            return reverse ? r0 - ratio * diffRange : r0 + ratio * diffRange;\n        });\n        // Compress the range scale according to breaks.\n        const [MIN, MAX] = RANGE_LIMIT;\n        sortedBreaks.forEach(({ start, end, gap = DEFAULT_GAP, compress = 'middle' }) => {\n            const startIndex = breaksDomain.indexOf(start);\n            const endIndex = breaksDomain.indexOf(end);\n            let value = (breaksRange[startIndex] + breaksRange[endIndex]) / 2;\n            if (compress === 'start')\n                value = breaksRange[startIndex];\n            if (compress === 'end')\n                value = breaksRange[endIndex];\n            const halfSpan = (gap * diffRange) / 2;\n            // Calculate the new start and end values based on the center and scaled span.\n            let startValue = reverse ? value + halfSpan : value - halfSpan;\n            let endValue = reverse ? value - halfSpan : value + halfSpan;\n            // Ensure the new start and end values are within the defined limits.\n            if (startValue < MIN) {\n                endValue += MIN - startValue;\n                startValue = MIN;\n            }\n            if (endValue > MAX) {\n                startValue -= endValue - MAX;\n                endValue = MAX;\n            }\n            if (startValue > MAX) {\n                endValue -= startValue - MAX;\n                startValue = MAX;\n            }\n            if (endValue < MIN) {\n                startValue += MIN - endValue;\n                endValue = MIN;\n            }\n            breaksRange[startIndex] = startValue;\n            breaksRange[endIndex] = endValue;\n        });\n        return this.removeUnsortedValues(breaksDomain, breaksRange, reverse);\n    }\n    transformBreaks(options) {\n        const { domain, breaks = [] } = options;\n        if (!isArray(options.breaks))\n            return options;\n        const domainMax = Math.max(...domain);\n        const filteredBreaks = breaks.filter(({ end }) => end < domainMax);\n        const optWithFilteredBreaks = { ...options, breaks: filteredBreaks };\n        const { breaksDomain, breaksRange } = this.transformDomain(optWithFilteredBreaks);\n        return {\n            ...options,\n            domain: breaksDomain,\n            range: breaksRange,\n            breaks: filteredBreaks,\n            tickMethod: () => [...breaksDomain],\n        };\n    }\n    chooseTransforms() {\n        return [identity, identity];\n    }\n    clone() {\n        return new Linear(this.options);\n    }\n}\n//# sourceMappingURL=linear.js.map"],"names":["Linear","Continuous","createInterpolateValue","d3Ticks","breaksDomain","breaksRange","reverse","pre","acc","current","i","value","index","options","RANGE_LIMIT","DEFAULT_GAP","domain","range","breaks","tickCount","nice","min","max","niceDomainMin","niceDomainMax","niceDomain","domainMin","domainMax","sortedBreaks","end","a","b","last","nicest","d3LinearNice","r0","r1","diffDomain","diffRange","d","ratio","MIN","MAX","start","gap","compress","startIndex","endIndex","halfSpan","startValue","endValue","isArray","filteredBreaks","optWithFilteredBreaks","identity"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/log.js

@@ -0,0 +1,35 @@
+import { Continuous as i } from "./continuous.js";
+import { d3Log as c } from "../tick-methods/d3-log.js";
+import { d3LogNice as m } from "../utils/d3-log-nice.js";
+import { createInterpolateValue as a } from "../utils/interpolate.js";
+import { logs as p, pows as u } from "../utils/log.js";
+class n extends i {
+  getDefaultOptions() {
+    return {
+      domain: [1, 10],
+      range: [0, 1],
+      base: 10,
+      interpolate: a,
+      tickMethod: c,
+      tickCount: 5
+    };
+  }
+  chooseNice() {
+    return m;
+  }
+  getTickMethodOptions() {
+    const { domain: o, tickCount: e, base: t } = this.options, r = o[0], s = o[o.length - 1];
+    return [r, s, e, t];
+  }
+  chooseTransforms() {
+    const { base: o, domain: e } = this.options, t = e[0] < 0;
+    return [p(o, t), u(o, t)];
+  }
+  clone() {
+    return new n(this.options);
+  }
+}
+export {
+  n as Log
+};
+//# sourceMappingURL=log.js.map

package/dist/node_modules/@antv/scale/esm/scales/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","sources":["../../../../../../node_modules/@antv/scale/esm/scales/log.js"],"sourcesContent":["import { Continuous } from './continuous';\nimport { createInterpolateValue, logs, pows } from '../utils';\nimport { d3Log } from '../tick-methods/d3-log';\nimport { d3LogNice } from '../utils/d3-log-nice';\n/**\n * Linear 比例尺\n *\n * 构造一个线性的对数比例尺\n */\nexport class Log extends Continuous {\n    getDefaultOptions() {\n        return {\n            domain: [1, 10],\n            range: [0, 1],\n            base: 10,\n            interpolate: createInterpolateValue,\n            tickMethod: d3Log,\n            tickCount: 5,\n        };\n    }\n    chooseNice() {\n        return d3LogNice;\n    }\n    getTickMethodOptions() {\n        const { domain, tickCount, base } = this.options;\n        const min = domain[0];\n        const max = domain[domain.length - 1];\n        return [min, max, tickCount, base];\n    }\n    chooseTransforms() {\n        const { base, domain } = this.options;\n        const shouldReflect = domain[0] < 0;\n        return [logs(base, shouldReflect), pows(base, shouldReflect)];\n    }\n    clone() {\n        return new Log(this.options);\n    }\n}\n//# sourceMappingURL=log.js.map"],"names":["Log","Continuous","createInterpolateValue","d3Log","d3LogNice","domain","tickCount","base","min","max","shouldReflect","logs","pows"],"mappings":";;;;;AASO,MAAMA,UAAYC,EAAW;AAAA,EAChC,oBAAoB;AAChB,WAAO;AAAA,MACH,QAAQ,CAAC,GAAG,EAAE;AAAA,MACd,OAAO,CAAC,GAAG,CAAC;AAAA,MACZ,MAAM;AAAA,MACN,aAAaC;AAAA,MACb,YAAYC;AAAA,MACZ,WAAW;AAAA,IACvB;AAAA,EACI;AAAA,EACA,aAAa;AACT,WAAOC;AAAA,EACX;AAAA,EACA,uBAAuB;AACnB,UAAM,EAAE,QAAAC,GAAQ,WAAAC,GAAW,MAAAC,EAAI,IAAK,KAAK,SACnCC,IAAMH,EAAO,CAAC,GACdI,IAAMJ,EAAOA,EAAO,SAAS,CAAC;AACpC,WAAO,CAACG,GAAKC,GAAKH,GAAWC,CAAI;AAAA,EACrC;AAAA,EACA,mBAAmB;AACf,UAAM,EAAE,MAAAA,GAAM,QAAAF,EAAM,IAAK,KAAK,SACxBK,IAAgBL,EAAO,CAAC,IAAI;AAClC,WAAO,CAACM,EAAKJ,GAAMG,CAAa,GAAGE,EAAKL,GAAMG,CAAa,CAAC;AAAA,EAChE;AAAA,EACA,QAAQ;AACJ,WAAO,IAAIV,EAAI,KAAK,OAAO;AAAA,EAC/B;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/scale/esm/scales/ordinal.js

@@ -0,0 +1,77 @@
+import { Base as m } from "./base.js";
+const p = Symbol("defaultUnknown");
+function s(i, n, t) {
+  for (let e = 0; e < n.length; e += 1)
+    i.has(n[e]) || i.set(t(n[e]), e);
+}
+function d(i) {
+  const { value: n, from: t, to: e, mapper: o, notFoundReturn: r } = i;
+  let a = o.get(n);
+  if (a === void 0) {
+    if (r !== p)
+      return r;
+    a = t.push(n) - 1, o.set(n, a);
+  }
+  return e[a % e.length];
+}
+function h(i) {
+  return i instanceof Date ? (n) => `${n}` : typeof i == "object" ? (n) => JSON.stringify(n) : (n) => n;
+}
+class u extends m {
+  // 覆盖默认配置
+  getDefaultOptions() {
+    return {
+      domain: [],
+      range: [],
+      unknown: p
+    };
+  }
+  // 显示指定 options 的类型为 OrdinalOptions，从而推断出 O 的类型
+  constructor(n) {
+    super(n);
+  }
+  map(n) {
+    return this.domainIndexMap.size === 0 && s(this.domainIndexMap, this.getDomain(), this.domainKey), d({
+      value: this.domainKey(n),
+      mapper: this.domainIndexMap,
+      from: this.getDomain(),
+      to: this.getRange(),
+      notFoundReturn: this.options.unknown
+    });
+  }
+  invert(n) {
+    return this.rangeIndexMap.size === 0 && s(this.rangeIndexMap, this.getRange(), this.rangeKey), d({
+      value: this.rangeKey(n),
+      mapper: this.rangeIndexMap,
+      from: this.getRange(),
+      to: this.getDomain(),
+      notFoundReturn: this.options.unknown
+    });
+  }
+  // 因为 ordinal 比例尺更新内部状态的开销较大，所以按需更新
+  rescale(n) {
+    const [t] = this.options.domain, [e] = this.options.range;
+    if (this.domainKey = h(t), this.rangeKey = h(e), !this.rangeIndexMap) {
+      this.rangeIndexMap = /* @__PURE__ */ new Map(), this.domainIndexMap = /* @__PURE__ */ new Map();
+      return;
+    }
+    (!n || n.range) && this.rangeIndexMap.clear(), (!n || n.domain || n.compare) && (this.domainIndexMap.clear(), this.sortedDomain = void 0);
+  }
+  clone() {
+    return new u(this.options);
+  }
+  getRange() {
+    return this.options.range;
+  }
+  getDomain() {
+    if (this.sortedDomain)
+      return this.sortedDomain;
+    const { domain: n, compare: t } = this.options;
+    return this.sortedDomain = t ? [...n].sort(t) : n, this.sortedDomain;
+  }
+}
+export {
+  u as Ordinal,
+  p as defaultUnknown
+};
+//# sourceMappingURL=ordinal.js.map