@antv/l7-layers 2.25.5 → 2.25.7

package/lib/utils/scale.js

@@ -1,610 +0,0 @@
-"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 - 返回 range 中值，避免所有值映射到最小值
-    if (d0 === d1) {
-      return (r0 + r1) / 2;
-    }
-    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];
-
-    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
-    if (d0 === d1) {
-      return (r0 + r1) / 2;
-    }
-    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];
-
-    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
-    if (d0 === d1) {
-      return (r0 + r1) / 2;
-    }
-    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];
-    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
-    if (d0 === d1) {
-      return _range[Math.floor(_range.length / 2)];
-    }
-    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];
-
-    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
-    if (d0 === d1) {
-      return (r0 + r1) / 2;
-    }
-    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/lib/utils/simpleLine.d.ts

@@ -1,23 +0,0 @@
-import { vec2 } from 'gl-matrix';
-export declare function direction(out: vec2, a: vec2, b: vec2): vec2;
-export default class ExtrudePolyline {
-    complex: {
-        positions: number[];
-        indices: number[];
-        startIndex: number;
-        indexes: number[];
-    };
-    private started;
-    private totalDistance;
-    private currentIndex;
-    constructor();
-    simpleExtrude(points: number[][]): {
-        positions: number[];
-        indices: number[];
-        startIndex: number;
-        indexes: number[];
-    };
-    private simpleSegment;
-    private extrusions;
-    private lineSegmentDistance;
-}

package/lib/utils/simpleLine.js

@@ -1,85 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.direction = direction;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _l7Utils = require("@antv/l7-utils");
-var _glMatrix = require("gl-matrix");
-const lineA = _glMatrix.vec2.create();
-function direction(out, a, b) {
-  _glMatrix.vec2.sub(out, a, b);
-  _glMatrix.vec2.normalize(out, out);
-  return out;
-}
-class ExtrudePolyline {
-  constructor() {
-    (0, _defineProperty2.default)(this, "complex", void 0);
-    (0, _defineProperty2.default)(this, "started", false);
-    (0, _defineProperty2.default)(this, "totalDistance", 0);
-    (0, _defineProperty2.default)(this, "currentIndex", 0);
-    this.complex = {
-      positions: [],
-      indices: [],
-      startIndex: 0,
-      indexes: []
-    };
-  }
-  simpleExtrude(points) {
-    const complex = this.complex;
-    if (points.length <= 1) {
-      return complex;
-    }
-    this.started = false;
-    this.totalDistance = 0;
-    const total = points.length;
-    let count = complex.startIndex;
-    for (let i = 1; i < total; i++) {
-      const last = points[i - 1];
-      const cur = points[i];
-      const amt = this.simpleSegment(complex, count, last, cur);
-      count += amt;
-    }
-    for (let i = 0; i < complex.positions.length / 6; i++) {
-      complex.positions[i * 6 + 5] = this.totalDistance;
-    }
-    return complex;
-  }
-  simpleSegment(complex, index, last, cur) {
-    let count = 0;
-    const indices = complex.indices;
-    const positions = complex.positions;
-    const flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
-    const flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
-    direction(lineA, flatCur, flatLast);
-    const segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
-    this.totalDistance += segmentDistance;
-    if (!this.started) {
-      this.started = true;
-      this.extrusions(positions, last, this.totalDistance - segmentDistance);
-    }
-    this.extrusions(positions, cur, this.totalDistance);
-    indices.push(index + 0, index + 1, index + 2);
-    indices.push(index + 2, index + 1, index + 3);
-    count += 2;
-    return count;
-  }
-  extrusions(positions, point,
-  // 顶点
-  distanceRadio) {
-    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
-    this.complex.indexes.push(this.currentIndex);
-    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
-    this.complex.indexes.push(this.currentIndex);
-    this.currentIndex++;
-  }
-  lineSegmentDistance(b1, a1) {
-    const dx = a1[0] - b1[0];
-    const dy = a1[1] - b1[1];
-    return Math.sqrt(dx * dx + dy * dy);
-  }
-}
-exports.default = ExtrudePolyline;