@antv/l7-layers 2.23.2 → 2.23.3-beta.1

package/lib/utils/scale.js

@@ -0,0 +1,603 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scaleDiverging = scaleDiverging;
+exports.scaleLinear = scaleLinear;
+exports.scaleLog = scaleLog;
+exports.scaleOrdinal = scaleOrdinal;
+exports.scalePow = scalePow;
+exports.scaleQuantile = scaleQuantile;
+exports.scaleQuantize = scaleQuantize;
+exports.scaleSequential = scaleSequential;
+exports.scaleThreshold = scaleThreshold;
+exports.scaleTime = scaleTime;
+/**
+ * 比例尺工具
+ * 用于替代 d3-scale 的功能
+ */
+
+// ==================== 工具函数 ====================
+
+function bisect(a, x, lo = 0, hi = a.length) {
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (a[mid] < x) lo = mid + 1;else hi = mid;
+  }
+  return lo;
+}
+function tickIncrement(start, stop, count) {
+  if (start === stop) return 0;
+  const d = stop - start;
+  const step = Math.pow(10, Math.floor(Math.log(d / count) / Math.LN10));
+  const err = count / d * step;
+  if (err <= 0.15) return step * 10;
+  if (err <= 0.35) return step * 5;
+  if (err <= 0.75) return step * 2;
+  return step;
+}
+function tickStep(start, stop, count) {
+  if (start === stop) return 1;
+  const d = stop - start;
+  const step0 = Math.abs(d) / Math.max(1, count);
+  let step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10));
+  const error = step0 / step1;
+  if (error >= 10) step1 *= 10;else if (error >= 5) step1 *= 5;else if (error >= 2) step1 *= 2;
+  return d < 0 ? -step1 : step1;
+}
+
+// 处理 domain 中的无效值
+function sanitizeDomain(d) {
+  const filtered = d.filter(v => v != null && !Number.isNaN(v) && typeof v === 'number');
+  if (filtered.length === 0) {
+    return [0, 1];
+  } else if (filtered.length === 1) {
+    return [filtered[0], filtered[0]];
+  }
+  return filtered;
+}
+
+// ==================== Linear Scale ====================
+
+function scaleLinear() {
+  let domain = [0, 1];
+  let range = [0, 1];
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+
+    // 处理相等的 domain
+    if (d0 === d1) {
+      return r0;
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    return d0 + (y - r0) / (r1 - r0) * (d1 - d0);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const step = tickStep(d0, d1, count);
+    const ticks = [];
+    let i = Math.floor(d0 / step);
+    const maxI = Math.ceil(d1 / step);
+    while (i <= maxI) {
+      ticks.push(i * step);
+      i++;
+    }
+    return ticks;
+  };
+  scale.nice = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return scale;
+    const step = tickIncrement(d0, d1, count);
+    if (step > 0) {
+      domain = [Math.floor(d0 / step) * step, Math.ceil(d1 / step) * step];
+    }
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Power Scale ====================
+
+function scalePow() {
+  let domain = [0, 1];
+  let range = [0, 1];
+  let _clamp = false;
+  let _exponent = 1;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    if (d0 === d1) {
+      return r0;
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    t = Math.pow(t, _exponent);
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    let t = (y - r0) / (r1 - r0);
+    t = Math.pow(t, 1 / _exponent);
+    return d0 + t * (d1 - d0);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const step = tickStep(d0, d1, count);
+    const ticks = [];
+    let i = Math.floor(d0 / step);
+    const maxI = Math.ceil(d1 / step);
+    while (i <= maxI) {
+      ticks.push(i * step);
+      i++;
+    }
+    return ticks;
+  };
+  scale.nice = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return scale;
+    const step = tickIncrement(d0, d1, count);
+    if (step > 0) {
+      domain = [Math.floor(d0 / step) * step, Math.ceil(d1 / step) * step];
+    }
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  scale.exponent = function (k) {
+    if (k === undefined) return _exponent;
+    _exponent = k;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Log Scale ====================
+
+function log(x, base) {
+  return Math.log(x) / Math.log(base);
+}
+function pow(x, base) {
+  return Math.pow(base, x);
+}
+function scaleLog() {
+  let domain = [1, 10];
+  let range = [0, 1];
+  let _clamp = false;
+  let _base = 10;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    if (d0 === d1) {
+      return r0;
+    }
+    const absD0 = Math.abs(d0) || 1;
+    const absD1 = Math.abs(d1) || 1;
+    const absX = Math.abs(x) || 1;
+    let t = (log(absX, _base) - log(absD0, _base)) / (log(absD1, _base) - log(absD0, _base));
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    const sanitized = sanitizeDomain(d);
+    // log scale 需要 正数domain
+    domain = sanitized.map(v => v <= 0 ? 1 : v);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    const t = (y - r0) / (r1 - r0);
+    const absD0 = Math.abs(d0) || 1;
+    const absD1 = Math.abs(d1) || 1;
+    return pow(log(absD0, _base) + t * (log(absD1, _base) - log(absD0, _base)), _base);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const ticks = [];
+    const startPow = Math.floor(log(Math.abs(d0) || 1, _base));
+    const endPow = Math.ceil(log(Math.abs(d1) || 1, _base));
+    for (let i = startPow; i <= endPow; i++) {
+      ticks.push(pow(i, _base));
+    }
+    return ticks;
+  };
+  scale.nice = function () {
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  scale.base = function (b) {
+    if (b === undefined) return _base;
+    _base = b;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Ordinal Scale ====================
+
+function scaleOrdinal(range) {
+  let domain = [];
+  let _range = range || [];
+  let _unknown;
+  const index = new Map();
+  function scale(x) {
+    let i = index.get(x);
+    if (i === undefined) {
+      if (_unknown !== undefined) return _unknown;
+      if (_range.length === 0) return undefined;
+      i = domain.push(x) - 1;
+      index.set(x, i);
+    }
+    return _range[i % _range.length];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = [];
+    index.clear();
+    d.forEach(x => {
+      if (!index.has(x)) {
+        index.set(x, domain.length);
+        domain.push(x);
+      }
+    });
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    return scale;
+  };
+  scale.unknown = function (value) {
+    _unknown = value;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Quantize Scale ====================
+
+function scaleQuantize() {
+  let domain = [0, 1];
+  let _range = [0, 1];
+  let n = 1;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) {
+      return _range[0];
+    }
+    const t = (x - d0) / (d1 - d0);
+    const i = Math.max(0, Math.min(n - 1, Math.floor(t * n)));
+    return _range[i];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    n = Math.max(1, _range.length);
+    return scale;
+  };
+  scale.invertExtent = function (y) {
+    const i = _range.indexOf(y);
+    if (i < 0) return [NaN, NaN];
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const step = (d1 - d0) / n;
+    return [d0 + i * step, d0 + (i + 1) * step];
+  };
+  return scale;
+}
+
+// ==================== Quantile Scale ====================
+
+function scaleQuantile() {
+  let _domain = [];
+  let _range = [0, 1];
+  let thresholds = [];
+  function scale(x) {
+    if (isNaN(x)) return _range[0];
+    const i = bisect(thresholds, x);
+    return _range[i];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return _domain.slice();
+    _domain = d.filter(x => x != null && !isNaN(x) && typeof x === 'number').sort((a, b) => a - b);
+    rescale();
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    rescale();
+    return scale;
+  };
+  scale.invertExtent = function (y) {
+    const i = _range.indexOf(y);
+    if (i < 0) return [NaN, NaN];
+    const n = _range.length;
+    return i > 0 ? [thresholds[i - 1], thresholds[i]] : [_domain[0], thresholds[0]];
+  };
+  scale.quantiles = function () {
+    return thresholds.slice();
+  };
+  function rescale() {
+    const n = _range.length;
+    const m = _domain.length;
+    if (m === 0 || n === 0) {
+      thresholds = [];
+      return;
+    }
+    thresholds = [];
+    for (let i = 1; i < n; i++) {
+      const q = i / n;
+      const index = (m - 1) * q;
+      const lower = Math.floor(index);
+      const upper = Math.ceil(index);
+      const weight = index - lower;
+      if (upper >= m) {
+        thresholds.push(_domain[m - 1]);
+      } else {
+        thresholds.push(_domain[lower] * (1 - weight) + _domain[upper] * weight);
+      }
+    }
+  }
+  return scale;
+}
+
+// ==================== Threshold Scale ====================
+
+function scaleThreshold() {
+  let _domain = [0.5];
+  let _range = [0, 1];
+  function scale(x) {
+    const i = bisect(_domain, x);
+    return _range[i];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return _domain.slice();
+    _domain = d.filter(v => v != null && !isNaN(v) && typeof v === 'number');
+    if (_domain.length === 0) {
+      _domain = [0.5];
+    }
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    return scale;
+  };
+  scale.invertExtent = function (y) {
+    const i = _range.indexOf(y);
+    return [i > 0 ? _domain[i - 1] : undefined, i < _domain.length ? _domain[i] : undefined];
+  };
+  return scale;
+}
+
+// ==================== Sequential Scale ====================
+
+function scaleSequential() {
+  let domain = [0, 1];
+  let _interpolator = t => t;
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) {
+      return _interpolator(0.5);
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return _interpolator(t);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.interpolator = function (i) {
+    if (i === undefined) return _interpolator;
+    _interpolator = i;
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Diverging Scale ====================
+
+function scaleDiverging() {
+  let domain = [0, 0.5, 1];
+  let _interpolator = t => t;
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[1];
+    const d2 = domain[2];
+    let t;
+    if (x < d1) {
+      if (d0 === d1) {
+        return _interpolator(0.5);
+      }
+      t = (x - d0) / (d1 - d0);
+      t = _clamp ? Math.max(0, t) : t;
+      return _interpolator(0.5 - t * 0.5);
+    } else {
+      if (d1 === d2) {
+        return _interpolator(0.5);
+      }
+      t = (x - d1) / (d2 - d1);
+      t = _clamp ? Math.min(1, t) : t;
+      return _interpolator(0.5 + t * 0.5);
+    }
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    // diverging scale 需要 3 个值
+    const sanitized = d.filter(v => v != null && !isNaN(v) && typeof v === 'number');
+    if (sanitized.length >= 3) {
+      domain = [sanitized[0], sanitized[1], sanitized[2]];
+    } else if (sanitized.length === 2) {
+      const mid = (sanitized[0] + sanitized[1]) / 2;
+      domain = [sanitized[0], mid, sanitized[1]];
+    } else if (sanitized.length === 1) {
+      domain = [sanitized[1], sanitized[0], sanitized[0] + 1];
+    } else {
+      domain = [0, 0.5, 1];
+    }
+    return scale;
+  };
+  scale.interpolator = function (i) {
+    if (i === undefined) return _interpolator;
+    _interpolator = i;
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Time Scale ====================
+
+function scaleTime() {
+  let domain = [0, 1];
+  let range = [0, 1];
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    if (d0 === d1) {
+      return r0;
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    return d0 + (y - r0) / (r1 - r0) * (d1 - d0);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const step = tickStep(d0, d1, count);
+    const ticks = [];
+    let i = Math.floor(d0 / step);
+    const maxI = Math.ceil(d1 / step);
+    while (i <= maxI) {
+      ticks.push(i * step);
+      i++;
+    }
+    return ticks;
+  };
+  scale.nice = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return scale;
+    const step = tickIncrement(d0, d1, count);
+    if (step > 0) {
+      domain = [Math.floor(d0 / step) * step, Math.ceil(d1 / step) * step];
+    }
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antv/l7-layers",
-  "version": "2.23.2",
+  "version": "2.23.3-beta.1",
   "description": "L7's collection of built-in layers",
   "license": "MIT",
   "author": "https://github.com/orgs/antvis/people",
@@ -23,29 +23,18 @@
     "@turf/meta": "^6.0.2",
     "@turf/polygon-to-line": "^6.5.0",
     "@turf/union": "^6.5.0",
-    "d3-array": "^2",
-    "d3-color": "^1.4.0",
-    "d3-interpolate": "1.4.0",
-    "d3-scale": "^2",
     "earcut": "^2.2.1",
     "eventemitter3": "^4.0.0",
-    "extrude-polyline": "^1.0.6",
     "gl-matrix": "^3.1.0",
-    "gl-vec2": "^1.3.0",
-    "polyline-miter-util": "^1.0.1",
-    "@antv/l7-core": "2.23.2",
-    "@antv/l7-maps": "2.23.2",
-    "@antv/l7-source": "2.23.2",
-    "@antv/l7-utils": "2.23.2"
+    "@antv/l7-core": "2.23.3-beta.1",
+    "@antv/l7-maps": "2.23.3-beta.1",
+    "@antv/l7-source": "2.23.3-beta.1",
+    "@antv/l7-utils": "2.23.3-beta.1"
   },
   "devDependencies": {
-    "@types/d3-array": "^2",
-    "@types/d3-color": "^1.2.2",
-    "@types/d3-interpolate": "1.1.6",
-    "@types/d3-scale": "^2.1.1",
     "@types/earcut": "^2.1.0",
     "@types/gl-matrix": "^2.4.5",
-    "@antv/l7-test-utils": "^2.23.2"
+    "@antv/l7-test-utils": "^2.23.3-beta.1"
   },
   "publishConfig": {
     "access": "public",