@antv/l7-layers 2.9.25-alpha.0 → 2.9.25

package/lib/core/BaseModel.js

@@ -1,68 +1,83 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-
-// src/core/BaseModel.ts
-var BaseModel_exports = {};
-__export(BaseModel_exports, {
-  default: () => BaseModel
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(BaseModel_exports);
-var import_l7_core = require("@antv/l7-core");
-var import_l7_utils = require("@antv/l7-utils");
-var import_d3_color = require("d3-color");
-var import_lodash = require("lodash");
-var import_blend = require("../utils/blend");
-var BaseModel = class {
-  constructor(layer) {
+exports.default = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _initializerDefineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/initializerDefineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _applyDecoratedDescriptor2 = _interopRequireDefault(require("@babel/runtime/helpers/applyDecoratedDescriptor"));
+
+var _initializerWarningHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/initializerWarningHelper"));
+
+var _l7Core = require("@antv/l7-core");
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _d3Color = require("d3-color");
+
+var _lodash = require("lodash");
+
+var _blend = require("../utils/blend");
+
+var _dec, _class, _descriptor;
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var BaseModel = (_dec = (0, _l7Core.lazyInject)(_l7Core.TYPES.IGlobalConfigService), (_class = /*#__PURE__*/function () {
+  // style texture data mapping
+  // 用于数据传递的数据纹理
+  // 默认有多少列（宽度）
+  // 计算得到的当前数据纹理有多少行（高度）
+  // 单个 cell 的长度
+  // 需要进行数据映射的属性集合
+  // style texture data mapping
+  function BaseModel(layer) {
+    (0, _classCallCheck2.default)(this, BaseModel);
+    (0, _initializerDefineProperty2.default)(this, "configService", _descriptor, this);
     this.layer = layer;
-    this.rendererService = layer.getContainer().get(import_l7_core.TYPES.IRendererService);
-    this.pickingService = layer.getContainer().get(import_l7_core.TYPES.IPickingService);
-    this.shaderModuleService = layer.getContainer().get(import_l7_core.TYPES.IShaderModuleService);
-    this.styleAttributeService = layer.getContainer().get(import_l7_core.TYPES.IStyleAttributeService);
-    this.mapService = layer.getContainer().get(import_l7_core.TYPES.IMapService);
-    this.iconService = layer.getContainer().get(import_l7_core.TYPES.IIconService);
-    this.fontService = layer.getContainer().get(import_l7_core.TYPES.IFontService);
-    this.cameraService = layer.getContainer().get(import_l7_core.TYPES.ICameraService);
-    this.layerService = layer.getContainer().get(import_l7_core.TYPES.ILayerService);
-    this.registerBuiltinAttributes();
+    this.rendererService = layer.getContainer().get(_l7Core.TYPES.IRendererService);
+    this.pickingService = layer.getContainer().get(_l7Core.TYPES.IPickingService);
+    this.shaderModuleService = layer.getContainer().get(_l7Core.TYPES.IShaderModuleService);
+    this.styleAttributeService = layer.getContainer().get(_l7Core.TYPES.IStyleAttributeService);
+    this.mapService = layer.getContainer().get(_l7Core.TYPES.IMapService);
+    this.iconService = layer.getContainer().get(_l7Core.TYPES.IIconService);
+    this.fontService = layer.getContainer().get(_l7Core.TYPES.IFontService);
+    this.cameraService = layer.getContainer().get(_l7Core.TYPES.ICameraService);
+    this.layerService = layer.getContainer().get(_l7Core.TYPES.ILayerService); // 注册 Attribute
+
+    this.registerBuiltinAttributes(); // 开启动画
+
     this.startModelAnimate();
-    const { createTexture2D } = this.rendererService;
+    var createTexture2D = this.rendererService.createTexture2D;
     this.createTexture2D = createTexture2D;
-    this.DATA_TEXTURE_WIDTH = 1024;
+    this.DATA_TEXTURE_WIDTH = 1024; // 数据纹理固定宽度
+
     this.rowCount = 1;
     this.cellLength = 0;
     this.cellProperties = [];
     this.cacheStyleProperties = {
-      thetaOffset: void 0,
-      opacity: void 0,
-      strokeOpacity: void 0,
-      strokeWidth: void 0,
-      stroke: void 0,
-      offsets: void 0
+      thetaOffset: undefined,
+      opacity: undefined,
+      strokeOpacity: undefined,
+      strokeWidth: undefined,
+      stroke: undefined,
+      offsets: undefined
     };
     this.stylePropertyesExist = {
       hasThetaOffset: 0,
@@ -72,254 +87,417 @@ var BaseModel = class {
       hasStroke: 0,
       hasOffsets: 0
     };
-    this.dataTextureTest = this.layerService.getOESTextureFloat();
+    this.dataTextureTest = this.layerService.getOESTextureFloat(); // 只有在不支持数据纹理的情况下进行赋值
+
     if (!this.dataTextureTest) {
       this.dataTexture = this.createTexture2D({
+        // data: new Uint8ClampedArray(4),
+        // 使用 Uint8ClampedArray 在 支付宝 环境中可能存在问题 UC 内核对格式有要求 L7 v2.7.18 版本发现
+        // Uint8ClampedArray 和 Uint8Array 没有实质性的区别
         data: new Uint8Array(4),
-        mag: import_l7_core.gl.NEAREST,
-        min: import_l7_core.gl.NEAREST,
+        mag: _l7Core.gl.NEAREST,
+        min: _l7Core.gl.NEAREST,
         width: 1,
         height: 1
       });
     }
-  }
-  clearLastCalRes() {
-    this.cellProperties = [];
-    this.cellLength = 0;
-    this.stylePropertyesExist = {
-      hasThetaOffset: 0,
-      hasOpacity: 0,
-      hasStrokeOpacity: 0,
-      hasStrokeWidth: 0,
-      hasStroke: 0,
-      hasOffsets: 0
-    };
-  }
-  getCellTypeLayout() {
-    if (this.dataTextureTest) {
-      return [
-        this.rowCount,
-        this.DATA_TEXTURE_WIDTH,
-        0,
-        0,
-        this.stylePropertyesExist.hasOpacity,
-        this.stylePropertyesExist.hasStrokeOpacity,
-        this.stylePropertyesExist.hasStrokeWidth,
-        this.stylePropertyesExist.hasStroke,
-        this.stylePropertyesExist.hasOffsets,
-        this.stylePropertyesExist.hasThetaOffset,
-        0,
-        0,
-        0,
-        0,
-        0,
-        1
-      ];
-    } else {
-      return [
-        1,
-        1,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        -1
-      ];
+  } // style datatexture mapping
+
+  /**
+   * 清除上一次的计算结果 - 全量清除
+   */
+
+
+  (0, _createClass2.default)(BaseModel, [{
+    key: "clearLastCalRes",
+    value: function clearLastCalRes() {
+      this.cellProperties = []; // 清空上一次计算的需要进行数据映射的属性集合
+
+      this.cellLength = 0; // 清空上一次计算的 cell 的长度
+
+      this.stylePropertyesExist = {
+        // 全量清空上一次是否需要对 style 属性进行数据映射的判断
+        hasThetaOffset: 0,
+        hasOpacity: 0,
+        hasStrokeOpacity: 0,
+        hasStrokeWidth: 0,
+        hasStroke: 0,
+        hasOffsets: 0
+      };
     }
-  }
-  dataTextureNeedUpdate(options) {
-    let isUpdate = false;
-    if (!(0, import_lodash.isEqual)(options.thetaOffset, this.cacheStyleProperties.thetaOffset)) {
-      isUpdate = true;
-      this.cacheStyleProperties.thetaOffset = options.thetaOffset;
+  }, {
+    key: "getCellTypeLayout",
+    value: function getCellTypeLayout() {
+      if (this.dataTextureTest) {
+        return [// 0
+        this.rowCount, // 数据纹理有几行
+        this.DATA_TEXTURE_WIDTH, // 数据纹理有几列
+        0.0, 0.0, // 1
+        this.stylePropertyesExist.hasOpacity, // cell 中是否存在 opacity
+        this.stylePropertyesExist.hasStrokeOpacity, // cell 中是否存在 strokeOpacity
+        this.stylePropertyesExist.hasStrokeWidth, // cell 中是否存在 strokeWidth
+        this.stylePropertyesExist.hasStroke, // cell 中是否存在 stroke
+        // 2
+        this.stylePropertyesExist.hasOffsets, // cell 中是否存在 offsets
+        this.stylePropertyesExist.hasThetaOffset, // cell 中是否存在 thetaOffset
+        0.0, 0.0, // 3
+        0.0, 0.0, 0.0, 1.0];
+      } else {
+        return [1.0, // 数据纹理有几行
+        1.0, // 数据纹理有几列
+        0.0, 0.0, 0.0, // cell 中是否存在 opacity
+        0.0, // cell 中是否存在 strokeOpacity
+        0.0, // cell 中是否存在 strokeWidth
+        0.0, // cell 中是否存在 stroke
+        0.0, // cell 中是否存在 offsets
+        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0];
+      }
     }
-    if (!(0, import_lodash.isEqual)(options.opacity, this.cacheStyleProperties.opacity)) {
-      isUpdate = true;
-      this.cacheStyleProperties.opacity = options.opacity;
+    /**
+     * 判断数据纹理是否需要重新计算 - 根据传入的值进行判断
+     * @param options
+     * @returns
+     */
+
+  }, {
+    key: "dataTextureNeedUpdate",
+    value: function dataTextureNeedUpdate(options) {
+      var isUpdate = false;
+
+      if (!(0, _lodash.isEqual)(options.thetaOffset, this.cacheStyleProperties.thetaOffset)) {
+        isUpdate = true;
+        this.cacheStyleProperties.thetaOffset = options.thetaOffset;
+      }
+
+      if (!(0, _lodash.isEqual)(options.opacity, this.cacheStyleProperties.opacity)) {
+        isUpdate = true;
+        this.cacheStyleProperties.opacity = options.opacity;
+      }
+
+      if (!(0, _lodash.isEqual)(options.strokeOpacity, this.cacheStyleProperties.strokeOpacity)) {
+        isUpdate = true;
+        this.cacheStyleProperties.strokeOpacity = options.strokeOpacity;
+      }
+
+      if (!(0, _lodash.isEqual)(options.strokeWidth, this.cacheStyleProperties.strokeWidth)) {
+        isUpdate = true;
+        this.cacheStyleProperties.strokeWidth = options.strokeWidth;
+      }
+
+      if (!(0, _lodash.isEqual)(options.stroke, this.cacheStyleProperties.stroke)) {
+        isUpdate = true;
+        this.cacheStyleProperties.stroke = options.stroke;
+      }
+
+      if (!(0, _lodash.isEqual)(options.offsets, this.cacheStyleProperties.offsets)) {
+        isUpdate = true;
+        this.cacheStyleProperties.offsets = options.offsets;
+      }
+
+      if (this.dataTexture === undefined) {
+        isUpdate = true;
+      }
+
+      return isUpdate;
     }
-    if (!(0, import_lodash.isEqual)(options.strokeOpacity, this.cacheStyleProperties.strokeOpacity)) {
-      isUpdate = true;
-      this.cacheStyleProperties.strokeOpacity = options.strokeOpacity;
+    /**
+     * 判断当前的样式中哪些是需要进行数据映射的，哪些是常量，同时计算用于构建数据纹理的一些中间变量
+     * @param options
+     */
+
+  }, {
+    key: "judgeStyleAttributes",
+    value: function judgeStyleAttributes(options) {
+      this.clearLastCalRes(); // 清除上一次的计算结果 - 全量清除
+
+      if (options.opacity !== undefined && !(0, _lodash.isNumber)(options.opacity)) {
+        // 数据映射
+        this.cellProperties.push({
+          attr: 'opacity',
+          count: 1
+        });
+        this.stylePropertyesExist.hasOpacity = 1;
+        this.cellLength += 1;
+      }
+
+      if (options.strokeOpacity !== undefined && !(0, _lodash.isNumber)(options.strokeOpacity)) {
+        // 数据映射
+        this.cellProperties.push({
+          attr: 'strokeOpacity',
+          count: 1
+        });
+        this.stylePropertyesExist.hasStrokeOpacity = 1;
+        this.cellLength += 1;
+      }
+
+      if (options.strokeWidth !== undefined && !(0, _lodash.isNumber)(options.strokeWidth)) {
+        // 数据映射
+        this.cellProperties.push({
+          attr: 'strokeWidth',
+          count: 1
+        });
+        this.stylePropertyesExist.hasStrokeWidth = 1;
+        this.cellLength += 1;
+      }
+
+      if (options.stroke !== undefined && !this.isStaticColor(options.stroke)) {
+        // 数据映射
+        this.cellProperties.push({
+          attr: 'stroke',
+          count: 4
+        });
+        this.stylePropertyesExist.hasStroke = 1;
+        this.cellLength += 4;
+      }
+
+      if (options.offsets !== undefined && !this.isOffsetStatic(options.offsets)) {
+        // 数据映射
+        this.cellProperties.push({
+          attr: 'offsets',
+          count: 2
+        });
+        this.stylePropertyesExist.hasOffsets = 1;
+        this.cellLength += 2;
+      }
+
+      if (options.thetaOffset !== undefined && !(0, _lodash.isNumber)(options.thetaOffset)) {
+        // 数据映射
+        this.cellProperties.push({
+          attr: 'thetaOffset',
+          count: 1
+        });
+        this.stylePropertyesExist.hasThetaOffset = 1;
+        this.cellLength += 1;
+      } // console.log('this.cellLength', this.cellLength)
+
     }
-    if (!(0, import_lodash.isEqual)(options.strokeWidth, this.cacheStyleProperties.strokeWidth)) {
-      isUpdate = true;
-      this.cacheStyleProperties.strokeWidth = options.strokeWidth;
+    /**
+     * 判断变量 stroke 是否是常量值
+     * @param stroke
+     * @returns
+     */
+
+  }, {
+    key: "isStaticColor",
+    value: function isStaticColor(stroke) {
+      if ((0, _lodash.isString)(stroke)) {
+        if ((0, _d3Color.color)(stroke)) {
+          return true;
+        } else {
+          return false;
+        }
+      }
+
+      return false;
     }
-    if (!(0, import_lodash.isEqual)(options.stroke, this.cacheStyleProperties.stroke)) {
-      isUpdate = true;
-      this.cacheStyleProperties.stroke = options.stroke;
+    /**
+     * 获取 stroke 颜色并做兼容处理
+     * @param stroke
+     * @returns
+     */
+
+  }, {
+    key: "getStrokeColor",
+    value: function getStrokeColor(stroke) {
+      if (this.isStaticColor(stroke)) {
+        var strokeColor = (0, _l7Utils.rgb2arr)(stroke);
+        strokeColor[0] = strokeColor[0] ? strokeColor[0] : 0;
+        strokeColor[1] = strokeColor[1] ? strokeColor[1] : 0;
+        strokeColor[2] = strokeColor[2] ? strokeColor[2] : 0;
+        strokeColor[3] = strokeColor[3] ? strokeColor[3] : 0;
+        return strokeColor;
+      } else {
+        return [0, 0, 0, 0];
+      }
     }
-    if (!(0, import_lodash.isEqual)(options.offsets, this.cacheStyleProperties.offsets)) {
-      isUpdate = true;
-      this.cacheStyleProperties.offsets = options.offsets;
+    /**
+     * 判断 offsets 是否是常量
+     * @param offsets
+     * @returns
+     */
+
+  }, {
+    key: "isOffsetStatic",
+    value: function isOffsetStatic(offsets) {
+      if (Array.isArray(offsets) && offsets.length === 2 && (0, _lodash.isNumber)(offsets[0]) && (0, _lodash.isNumber)(offsets[1])) {
+        return true;
+      } else {
+        return false;
+      }
     }
-    if (this.dataTexture === void 0) {
-      isUpdate = true;
+    /**
+     * 补空位
+     * @param d
+     * @param count
+     */
+
+  }, {
+    key: "patchMod",
+    value: function patchMod(d, count) {
+      for (var i = 0; i < count; i++) {
+        d.push(-1);
+      }
     }
-    return isUpdate;
-  }
-  judgeStyleAttributes(options) {
-    this.clearLastCalRes();
-    if (options.opacity !== void 0 && !(0, import_lodash.isNumber)(options.opacity)) {
-      this.cellProperties.push({ attr: "opacity", count: 1 });
-      this.stylePropertyesExist.hasOpacity = 1;
-      this.cellLength += 1;
+    /**
+     * 根据映射的数据字段往推入数据
+     * @param d
+     * @param cellData
+     * @param cellPropertiesLayouts
+     */
+
+  }, {
+    key: "patchData",
+    value: function patchData(d, cellData, cellPropertiesLayouts) {
+      var _iterator = _createForOfIteratorHelper(cellPropertiesLayouts),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var layout = _step.value;
+          var attr = layout.attr,
+              count = layout.count;
+          var value = cellData[attr];
+
+          if (value !== undefined) {
+            // 数据中存在该属性
+            if (attr === 'stroke') {
+              d.push.apply(d, (0, _toConsumableArray2.default)((0, _l7Utils.rgb2arr)(value)));
+            } else if (attr === 'offsets') {
+              if (this.isOffsetStatic(value)) {
+                d.push(-value[0], value[1]);
+              } else {
+                d.push(0, 0);
+              }
+            } else {
+              d.push((0, _lodash.isNumber)(value) ? value : 1.0);
+            }
+          } else {
+            // 若不存在时则补位
+            this.patchMod(d, count);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
     }
-    if (options.strokeOpacity !== void 0 && !(0, import_lodash.isNumber)(options.strokeOpacity)) {
-      this.cellProperties.push({ attr: "strokeOpacity", count: 1 });
-      this.stylePropertyesExist.hasStrokeOpacity = 1;
-      this.cellLength += 1;
+    /**
+     * 计算推入数据纹理的数据
+     * @param cellLength
+     * @param encodeData
+     * @param cellPropertiesLayouts
+     * @returns
+     */
+
+  }, {
+    key: "calDataFrame",
+    value: function calDataFrame(cellLength, encodeData, cellPropertiesLayouts) {
+      var encodeDatalength = encodeData.length;
+      var rowCount = Math.ceil(encodeDatalength * cellLength / this.DATA_TEXTURE_WIDTH); // 有多少行
+
+      var totalLength = rowCount * this.DATA_TEXTURE_WIDTH;
+      var d = [];
+
+      for (var i = 0; i < encodeDatalength; i++) {
+        // 根据 encodeData 数据推入数据
+        var cellData = encodeData[i];
+        this.patchData(d, cellData, cellPropertiesLayouts);
+      }
+
+      for (var _i = d.length; _i < totalLength; _i++) {
+        // 每行不足的部分用 -1 补足（数据纹理时 width * height 的矩形数据集合）
+        d.push(-1);
+      } // console.log('data', d)
+
+
+      return {
+        data: d,
+        width: this.DATA_TEXTURE_WIDTH,
+        height: rowCount
+      };
+    } // style datatexture mapping
+
+  }, {
+    key: "getBlend",
+    value: function getBlend() {
+      var _this$layer$getLayerC = this.layer.getLayerConfig(),
+          _this$layer$getLayerC2 = _this$layer$getLayerC.blend,
+          blend = _this$layer$getLayerC2 === void 0 ? 'normal' : _this$layer$getLayerC2;
+
+      return _blend.BlendTypes[_l7Core.BlendType[blend]];
     }
-    if (options.strokeWidth !== void 0 && !(0, import_lodash.isNumber)(options.strokeWidth)) {
-      this.cellProperties.push({ attr: "strokeWidth", count: 1 });
-      this.stylePropertyesExist.hasStrokeWidth = 1;
-      this.cellLength += 1;
+  }, {
+    key: "getDefaultStyle",
+    value: function getDefaultStyle() {
+      return {};
     }
-    if (options.stroke !== void 0 && !this.isStaticColor(options.stroke)) {
-      this.cellProperties.push({ attr: "stroke", count: 4 });
-      this.stylePropertyesExist.hasStroke = 1;
-      this.cellLength += 4;
+  }, {
+    key: "getUninforms",
+    value: function getUninforms() {
+      throw new Error('Method not implemented.');
     }
-    if (options.offsets !== void 0 && !this.isOffsetStatic(options.offsets)) {
-      this.cellProperties.push({ attr: "offsets", count: 2 });
-      this.stylePropertyesExist.hasOffsets = 1;
-      this.cellLength += 2;
+  }, {
+    key: "getAnimateUniforms",
+    value: function getAnimateUniforms() {
+      return {};
     }
-    if (options.thetaOffset !== void 0 && !(0, import_lodash.isNumber)(options.thetaOffset)) {
-      this.cellProperties.push({ attr: "thetaOffset", count: 1 });
-      this.stylePropertyesExist.hasThetaOffset = 1;
-      this.cellLength += 1;
+  }, {
+    key: "needUpdate",
+    value: function needUpdate() {
+      return false;
     }
-  }
-  isStaticColor(stroke) {
-    if ((0, import_lodash.isString)(stroke)) {
-      if ((0, import_d3_color.color)(stroke)) {
-        return true;
-      } else {
-        return false;
-      }
+  }, {
+    key: "buildModels",
+    value: function buildModels(callbackModel) {
+      throw new Error('Method not implemented.');
     }
-    return false;
-  }
-  getStrokeColor(stroke) {
-    if (this.isStaticColor(stroke)) {
-      const strokeColor = (0, import_l7_utils.rgb2arr)(stroke);
-      strokeColor[0] = strokeColor[0] ? strokeColor[0] : 0;
-      strokeColor[1] = strokeColor[1] ? strokeColor[1] : 0;
-      strokeColor[2] = strokeColor[2] ? strokeColor[2] : 0;
-      strokeColor[3] = strokeColor[3] ? strokeColor[3] : 0;
-      return strokeColor;
-    } else {
-      return [0, 0, 0, 0];
+  }, {
+    key: "initModels",
+    value: function initModels(callbackModel) {
+      throw new Error('Method not implemented.');
     }
-  }
-  isOffsetStatic(offsets) {
-    if (Array.isArray(offsets) && offsets.length === 2 && (0, import_lodash.isNumber)(offsets[0]) && (0, import_lodash.isNumber)(offsets[1])) {
-      return true;
-    } else {
-      return false;
+  }, {
+    key: "clearModels",
+    value: function clearModels() {
+      return;
     }
-  }
-  patchMod(d, count) {
-    for (let i = 0; i < count; i++) {
-      d.push(-1);
+  }, {
+    key: "getAttribute",
+    value: function getAttribute() {
+      throw new Error('Method not implemented.');
     }
-  }
-  patchData(d, cellData, cellPropertiesLayouts) {
-    for (const layout of cellPropertiesLayouts) {
-      const { attr, count } = layout;
-      const value = cellData[attr];
-      if (value !== void 0) {
-        if (attr === "stroke") {
-          d.push(...(0, import_l7_utils.rgb2arr)(value));
-        } else if (attr === "offsets") {
-          if (this.isOffsetStatic(value)) {
-            d.push(-value[0], value[1]);
-          } else {
-            d.push(0, 0);
-          }
-        } else {
-          d.push((0, import_lodash.isNumber)(value) ? value : 1);
-        }
-      } else {
-        this.patchMod(d, count);
-      }
+  }, {
+    key: "render",
+    value: function render() {
+      throw new Error('Method not implemented.');
     }
-  }
-  calDataFrame(cellLength, encodeData, cellPropertiesLayouts) {
-    const encodeDatalength = encodeData.length;
-    const rowCount = Math.ceil(encodeDatalength * cellLength / this.DATA_TEXTURE_WIDTH);
-    const totalLength = rowCount * this.DATA_TEXTURE_WIDTH;
-    const d = [];
-    for (let i = 0; i < encodeDatalength; i++) {
-      const cellData = encodeData[i];
-      this.patchData(d, cellData, cellPropertiesLayouts);
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes() {
+      throw new Error('Method not implemented.');
     }
-    for (let i = d.length; i < totalLength; i++) {
-      d.push(-1);
+  }, {
+    key: "animateOption2Array",
+    value: function animateOption2Array(option) {
+      return [option.enable ? 0 : 1.0, option.duration || 4.0, option.interval || 0.2, option.trailLength || 0.1];
     }
-    return { data: d, width: this.DATA_TEXTURE_WIDTH, height: rowCount };
-  }
-  getBlend() {
-    const { blend = "normal" } = this.layer.getLayerConfig();
-    return import_blend.BlendTypes[import_l7_core.BlendType[blend]];
-  }
-  getDefaultStyle() {
-    return {};
-  }
-  getUninforms() {
-    throw new Error("Method not implemented.");
-  }
-  getAnimateUniforms() {
-    return {};
-  }
-  needUpdate() {
-    return false;
-  }
-  buildModels(callbackModel) {
-    throw new Error("Method not implemented.");
-  }
-  initModels(callbackModel) {
-    throw new Error("Method not implemented.");
-  }
-  clearModels() {
-    return;
-  }
-  getAttribute() {
-    throw new Error("Method not implemented.");
-  }
-  render() {
-    throw new Error("Method not implemented.");
-  }
-  registerBuiltinAttributes() {
-    throw new Error("Method not implemented.");
-  }
-  animateOption2Array(option) {
-    return [
-      option.enable ? 0 : 1,
-      option.duration || 4,
-      option.interval || 0.2,
-      option.trailLength || 0.1
-    ];
-  }
-  startModelAnimate() {
-    const { animateOption } = this.layer.getLayerConfig();
-    if (animateOption.enable) {
-      this.layer.setAnimateStartTime();
+  }, {
+    key: "startModelAnimate",
+    value: function startModelAnimate() {
+      var _ref = this.layer.getLayerConfig(),
+          animateOption = _ref.animateOption;
+
+      if (animateOption.enable) {
+        this.layer.setAnimateStartTime();
+      }
     }
-  }
-};
-__decorateClass([
-  (0, import_l7_core.lazyInject)(import_l7_core.TYPES.IGlobalConfigService)
-], BaseModel.prototype, "configService", 2);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+  }]);
+  return BaseModel;
+}(), (_descriptor = (0, _applyDecoratedDescriptor2.default)(_class.prototype, "configService", [_dec], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class));
+exports.default = BaseModel;