@ohuoy/easymap 1.0.0 → 1.0.1

package/lib/@antv/l7-core/es/services/layer/IStyleAttributeService.d.ts

@@ -0,0 +1,178 @@
+import type { IAttribute, IAttributeInitializationOptions } from '../renderer/IAttribute';
+import type { IBufferInitializationOptions } from '../renderer/IBuffer';
+import type { IElements } from '../renderer/IElements';
+import type { ILayer } from './ILayerService';
+/**
+ * 1. 提供各个 Layer 样式属性初始值的注册服务
+ * 2. 当 Layer 通过 style() 改变某些样式属性时，需要感知并标记该属性已经失效，
+ *    随后当 Layer 重绘时通过 dirty 标记进行脏检查。重新传入 uniform 或者构建顶点数据（更新 Buffer 中的指定位置）。
+ * @see https://yuque.antfin-inc.com/yuqi.pyq/fgetpa/qfuzg8
+ */
+export declare enum ScaleTypes {
+    LINEAR = "linear",
+    SEQUENTIAL = "sequential",
+    POWER = "power",
+    LOG = "log",
+    IDENTITY = "identity",
+    TIME = "time",
+    QUANTILE = "quantile",
+    QUANTIZE = "quantize",
+    THRESHOLD = "threshold",
+    CAT = "cat",
+    DIVERGING = "diverging",
+    CUSTOM = "threshold"
+}
+export type ScaleTypeName = 'linear' | 'power' | 'log' | 'identity' | 'time' | 'quantile' | 'quantize' | 'threshold' | 'diverging' | 'sequential' | 'cat' | 'custom';
+export type ScaleAttributeType = 'color' | 'size' | 'shape';
+export interface IScale {
+    type: ScaleTypeName;
+    neutral?: number;
+    field?: string;
+    unknown?: string;
+    ticks?: any[];
+    nice?: boolean;
+    clamp?: boolean;
+    format?: () => any;
+    domain?: any[];
+    range?: any[];
+}
+export declare enum StyleScaleType {
+    CONSTANT = "constant",
+    VARIABLE = "variable"
+}
+export interface IScaleOption extends IScale {
+    attr?: ScaleAttributeType;
+}
+export interface IScaleOptions {
+    [key: string]: IScale | undefined;
+}
+export interface IStyleScale {
+    scale: any;
+    field: string | number;
+    type: StyleScaleType;
+    option: IScaleOption | undefined;
+}
+export declare enum AttributeType {
+    Attribute = 0,
+    InstancedAttribute = 1,
+    Uniform = 2
+}
+export interface IAnimateOption {
+    enable: boolean;
+    type?: string;
+    interval?: number;
+    duration?: number;
+    trailLength?: number;
+    repeat?: number;
+    speed?: number;
+    rings?: number;
+}
+export interface IEncodeFeature {
+    color?: Color;
+    size?: number | number[];
+    shape?: string | number;
+    pattern?: string;
+    id?: number;
+    coordinates: Position | Position[] | Position[][];
+    [key: string]: any;
+}
+export interface IVertexAttributeDescriptor extends Omit<IAttributeInitializationOptions, 'buffer'> {
+    /**
+     * attribute name in vertex shader
+     */
+    name: string;
+    /**
+     * 创建 buffer 的参数
+     */
+    buffer: IBufferInitializationOptions;
+    update?: (feature: IEncodeFeature, featureIdx: number, vertex: number[], attributeIdx: number, normal: number[], vertexIndex?: number) => number[];
+}
+export type Position = number[];
+type Color = [number, number, number, number];
+type CallBack = (...args: any[]) => any;
+export type StyleAttributeField = string | string[] | number[] | number;
+export type StyleAttributeOption = string | number | boolean | any[] | CallBack;
+export type StyleAttrField = string | string[] | number | number[];
+export interface IAttributeScale {
+    field: string | number;
+    func: unknown;
+    option: IScaleOption | undefined;
+}
+export interface IStyleAttributeInitializationOptions {
+    name: string;
+    type: AttributeType;
+    scale?: {
+        field: StyleAttributeField;
+        values: unknown[] | string;
+        defaultValues: unknown[] | string;
+        names: string[] | number[];
+        type: StyleScaleType;
+        callback?: (...args: any[]) => [];
+        scalers?: IAttributeScale[];
+    };
+    descriptor: IVertexAttributeDescriptor;
+}
+export interface IScaleValue {
+    field: StyleAttributeField | undefined;
+    values: unknown[] | string | undefined;
+    callback?: (...args: any[]) => [] | undefined;
+}
+export interface IFeatureRange {
+    startIndex: number;
+    endIndex: number;
+}
+export interface IStyleAttribute extends IStyleAttributeInitializationOptions {
+    needRescale: boolean;
+    needRemapping: boolean;
+    needRegenerateVertices: boolean;
+    featureRange: IFeatureRange;
+    /**
+     * 保存渲染层 IAttribute 引用
+     */
+    vertexAttribute: IAttribute;
+    mapping?(...params: unknown[]): unknown[];
+    setProps(props: Partial<IStyleAttributeInitializationOptions>): void;
+    resetDescriptor(): void;
+}
+export type Triangulation = (feature: IEncodeFeature, styleOption?: unknown) => {
+    vertices: number[];
+    indices: number[];
+    size: number;
+    normals?: number[];
+    indexes?: number[];
+    count?: number;
+};
+export interface IStyleAttributeUpdateOptions {
+    featureRange: IFeatureRange;
+}
+export interface IStyleAttributeService {
+    attributesAndIndices: {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+        elements: IElements;
+    };
+    registerStyleAttribute(options: Partial<IStyleAttributeInitializationOptions>): IStyleAttribute;
+    unRegisterStyleAttribute(name: string): void;
+    updateScaleAttribute(scale: IScaleOptions): void;
+    updateStyleAttribute(attributeName: string, attributeOptions: Partial<IStyleAttributeInitializationOptions>, updateOptions: IStyleAttributeUpdateOptions): void;
+    getLayerStyleAttributes(): IStyleAttribute[] | undefined;
+    getLayerStyleAttribute(attributeName: string): IStyleAttribute | undefined;
+    getLayerAttributeScale(attributeName: string): any;
+    createAttributesAndIndices(encodedFeatures: IEncodeFeature[], triangulation?: Triangulation, styleOption?: unknown, layer?: ILayer): {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+        elements: IElements;
+        count: number | null;
+    };
+    /**
+     * 根据 feature range 更新指定属性
+     */
+    updateAttributeByFeatureRange(attributeName: string, features: IEncodeFeature[], startFeatureIdx?: number, endFeatureIdx?: number, layer?: ILayer): void;
+    /**
+     * 清除当前管理的所有属性
+     */
+    clearAllAttributes(): void;
+}
+export {};

package/lib/@antv/l7-core/es/services/layer/IStyleAttributeService.js

@@ -0,0 +1,33 @@
+/**
+ * 1. 提供各个 Layer 样式属性初始值的注册服务
+ * 2. 当 Layer 通过 style() 改变某些样式属性时，需要感知并标记该属性已经失效，
+ *    随后当 Layer 重绘时通过 dirty 标记进行脏检查。重新传入 uniform 或者构建顶点数据（更新 Buffer 中的指定位置）。
+ * @see https://yuque.antfin-inc.com/yuqi.pyq/fgetpa/qfuzg8
+ */
+
+export let ScaleTypes = /*#__PURE__*/function (ScaleTypes) {
+  ScaleTypes["LINEAR"] = "linear";
+  ScaleTypes["SEQUENTIAL"] = "sequential";
+  ScaleTypes["POWER"] = "power";
+  ScaleTypes["LOG"] = "log";
+  ScaleTypes["IDENTITY"] = "identity";
+  ScaleTypes["TIME"] = "time";
+  ScaleTypes["QUANTILE"] = "quantile";
+  ScaleTypes["QUANTIZE"] = "quantize";
+  ScaleTypes["THRESHOLD"] = "threshold";
+  ScaleTypes["CAT"] = "cat";
+  ScaleTypes["DIVERGING"] = "diverging";
+  ScaleTypes["CUSTOM"] = "threshold";
+  return ScaleTypes;
+}({});
+export let StyleScaleType = /*#__PURE__*/function (StyleScaleType) {
+  StyleScaleType["CONSTANT"] = "constant";
+  StyleScaleType["VARIABLE"] = "variable";
+  return StyleScaleType;
+}({});
+export let AttributeType = /*#__PURE__*/function (AttributeType) {
+  AttributeType[AttributeType["Attribute"] = 0] = "Attribute";
+  AttributeType[AttributeType["InstancedAttribute"] = 1] = "InstancedAttribute";
+  AttributeType[AttributeType["Uniform"] = 2] = "Uniform";
+  return AttributeType;
+}({});

package/lib/@antv/l7-core/es/services/layer/LayerService.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'eventemitter3';
+import type { L7Container } from '../../inversify.config';
+import Clock from '../../utils/clock';
+import type { ILayer, ILayerService, LayerServiceEvent } from './ILayerService';
+export default class LayerService extends EventEmitter<LayerServiceEvent> implements ILayerService {
+    private container;
+    pickedLayerId: number;
+    clock: Clock;
+    alreadyInRendering: boolean;
+    private layers;
+    private layerList;
+    private layerRenderID;
+    private sceneInited;
+    private animateInstanceCount;
+    private shaderPicking;
+    private enableRender;
+    private get renderService();
+    private get mapService();
+    private get debugService();
+    constructor(container: L7Container);
+    reRender: import("@antv/l7-utils").DebouncedFunc<() => void>;
+    throttleRenderLayers: import("@antv/l7-utils").DebouncedFunc<() => void>;
+    needPick(type: string): boolean;
+    add(layer: ILayer): void;
+    addMask(mask: ILayer): void;
+    initLayers(): Promise<void>;
+    getSceneInited(): boolean;
+    getRenderList(): ILayer[];
+    getLayers(): ILayer[];
+    getLayer(id: string): ILayer | undefined;
+    getLayerByName(name: string): ILayer | undefined;
+    remove(layer: ILayer, parentLayer?: ILayer): Promise<void>;
+    removeAllLayers(): Promise<void>;
+    setEnableRender(flag: boolean): void;
+    renderLayers(): Promise<void>;
+    renderMask(masks: ILayer[]): void;
+    beforeRenderData(layer: ILayer): Promise<void>;
+    renderTileLayerMask(layer: ILayer): void;
+    renderTileLayer(layer: ILayer): Promise<void>;
+    updateLayerRenderList(): void;
+    destroy(): void;
+    startAnimate(): void;
+    stopAnimate(): void;
+    getOESTextureFloat(): boolean;
+    enableShaderPick(): void;
+    disableShaderPick(): void;
+    getShaderPickStat(): boolean;
+    clear(): void;
+    private runRender;
+    private stopRender;
+}

package/lib/@antv/l7-core/es/services/layer/LayerService.js

@@ -0,0 +1,289 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { lodashUtil, rgb2arr } from '@antv/l7-utils';
+import { EventEmitter } from 'eventemitter3';
+import Clock from "../../utils/clock";
+import { MaskOperation, StencilType } from "./ILayerService";
+const {
+  throttle
+} = lodashUtil;
+export default class LayerService extends EventEmitter {
+  get renderService() {
+    return this.container.rendererService;
+  }
+  get mapService() {
+    return this.container.mapService;
+  }
+  get debugService() {
+    return this.container.debugService;
+  }
+  constructor(container) {
+    super();
+    // pickedLayerId 参数用于指定当前存在被选中的 layer
+    _defineProperty(this, "pickedLayerId", -1);
+    _defineProperty(this, "clock", new Clock());
+    _defineProperty(this, "alreadyInRendering", false);
+    _defineProperty(this, "layers", []);
+    _defineProperty(this, "layerList", []);
+    _defineProperty(this, "layerRenderID", void 0);
+    _defineProperty(this, "sceneInited", false);
+    _defineProperty(this, "animateInstanceCount", 0);
+    // TODO: 是否开启 shader 中的颜色拾取计算
+    _defineProperty(this, "shaderPicking", true);
+    _defineProperty(this, "enableRender", true);
+    _defineProperty(this, "reRender", throttle(() => {
+      this.renderLayers();
+    }, 32));
+    _defineProperty(this, "throttleRenderLayers", throttle(() => {
+      this.renderLayers();
+    }, 16));
+    this.container = container;
+  }
+  needPick(type) {
+    this.updateLayerRenderList();
+    return this.layerList.some(layer => layer.needPick(type));
+  }
+  add(layer) {
+    this.layers.push(layer);
+    if (this.sceneInited) {
+      layer.init().then(() => {
+        this.renderLayers();
+      });
+    }
+  }
+  addMask(mask) {
+    if (this.sceneInited) {
+      mask.init().then(() => {
+        this.renderLayers();
+      });
+    }
+  }
+  initLayers() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      _this.sceneInited = true;
+      _this.layers.forEach( /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (layer) {
+          if (!layer.startInit) {
+            yield layer.init();
+            _this.updateLayerRenderList();
+          }
+        });
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    })();
+  }
+  getSceneInited() {
+    return this.sceneInited;
+  }
+  getRenderList() {
+    return this.layerList;
+  }
+  getLayers() {
+    return this.layers;
+  }
+  getLayer(id) {
+    return this.layers.find(layer => layer.id === id);
+  }
+  getLayerByName(name) {
+    return this.layers.find(layer => layer.name === name);
+  }
+  remove(layer, parentLayer) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      // Tip: layer.layerChildren 当 layer 存在子图层的情况
+      if (parentLayer) {
+        parentLayer.layerChildren = parentLayer.layerChildren.filter(item => item !== layer);
+      } else {
+        _this2.layers = _this2.layers.filter(item => item !== layer);
+      }
+      layer.destroy();
+      _this2.reRender();
+      _this2.emit('layerChange', _this2.layers);
+    })();
+  }
+  removeAllLayers() {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      _this3.destroy();
+      _this3.reRender();
+    })();
+  }
+  setEnableRender(flag) {
+    this.enableRender = flag;
+  }
+  renderLayers() {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      if (_this4.alreadyInRendering || !_this4.enableRender) {
+        return;
+      }
+      _this4.updateLayerRenderList();
+      const renderUid = _this4.debugService.generateRenderUid();
+      _this4.debugService.renderStart(renderUid);
+      _this4.alreadyInRendering = true;
+      _this4.clear();
+      for (const layer of _this4.layerList) {
+        layer.prerender();
+      }
+
+      // The main render pass, all layers in a whole.
+      _this4.renderService.beginFrame();
+      for (const layer of _this4.layerList) {
+        const {
+          enableMask
+        } = layer.getLayerConfig();
+        if (layer.masks.filter(m => m.inited).length > 0 && enableMask) {
+          // 清除上一次的模版缓存
+          _this4.renderMask(layer.masks);
+        }
+        if (layer.getLayerConfig().enableMultiPassRenderer) {
+          // multiPassRender 不是同步渲染完成的
+          yield layer.renderMultiPass();
+        } else {
+          layer.render();
+        }
+      }
+      _this4.renderService.endFrame();
+      _this4.debugService.renderEnd(renderUid);
+      _this4.alreadyInRendering = false;
+    })();
+  }
+  renderMask(masks) {
+    let maskIndex = 0;
+    this.renderService.clear({
+      stencil: 0,
+      depth: 1,
+      framebuffer: null
+    });
+    const stencilType = masks.length > 1 ? StencilType.MULTIPLE : StencilType.SINGLE;
+    for (const layer of masks) {
+      // 清除上一次的模版缓存
+      layer.render({
+        isStencil: true,
+        stencilType,
+        stencilIndex: maskIndex++
+      });
+    }
+  }
+  beforeRenderData(layer) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      const flag = yield layer.hooks.beforeRenderData.promise();
+      if (flag) {
+        _this5.renderLayers();
+      }
+    })();
+  }
+  renderTileLayerMask(layer) {
+    let maskindex = 0;
+    const {
+      enableMask = true
+    } = layer.getLayerConfig();
+    let maskCount = layer.tileMask ? 1 : 0; // 瓦片裁剪 线图层或者面图层
+    const masklayers = layer.masks.filter(m => m.inited);
+    maskCount = maskCount + (enableMask ? masklayers.length : 1);
+    const stencilType = maskCount > 1 ? StencilType.MULTIPLE : StencilType.SINGLE;
+    //  兼容MaskLayer MaskLayer的掩模不能clear
+    if (layer.tileMask || masklayers.length && enableMask) {
+      this.renderService.clear({
+        stencil: 0,
+        depth: 1,
+        framebuffer: null
+      });
+    }
+    if (masklayers.length && enableMask) {
+      for (const mask of masklayers) {
+        mask.render({
+          isStencil: true,
+          stencilType,
+          stencilIndex: maskindex++
+        });
+      }
+    }
+    // // 瓦片裁剪
+    if (layer.tileMask) {
+      layer.tileMask.render({
+        isStencil: true,
+        stencilType,
+        stencilIndex: maskindex++,
+        stencilOperation: MaskOperation.OR
+      });
+    }
+  }
+  // 瓦片图层渲染
+  renderTileLayer(layer) {
+    var _this6 = this;
+    return _asyncToGenerator(function* () {
+      _this6.renderTileLayerMask(layer);
+      if (layer.getLayerConfig().enableMultiPassRenderer) {
+        // multiPassRender 不是同步渲染完成的
+        yield layer.renderMultiPass();
+      } else {
+        yield layer.render();
+      }
+    })();
+  }
+  updateLayerRenderList() {
+    // Tip: 每次更新都是从 layers 重新构建
+    this.layerList = [];
+    this.layers.filter(layer => layer.inited).filter(layer => layer.isVisible()).sort((pre, next) => {
+      // 根据 zIndex 对渲染顺序进行排序
+      return pre.zIndex - next.zIndex;
+    }).forEach(layer => {
+      this.layerList.push(layer);
+    });
+  }
+  destroy() {
+    this.layers.forEach(layer => {
+      layer.destroy();
+    });
+    this.layers = [];
+    this.layerList = [];
+    this.emit('layerChange', this.layers);
+  }
+  startAnimate() {
+    if (this.animateInstanceCount++ === 0) {
+      this.clock.start();
+      this.runRender();
+    }
+  }
+  stopAnimate() {
+    if (--this.animateInstanceCount === 0) {
+      this.stopRender();
+      this.clock.stop();
+    }
+  }
+  getOESTextureFloat() {
+    return this.renderService.extensionObject.OES_texture_float;
+  }
+
+  // 控制着色器颜色拾取计算
+  enableShaderPick() {
+    this.shaderPicking = true;
+  }
+  disableShaderPick() {
+    this.shaderPicking = false;
+  }
+  getShaderPickStat() {
+    return this.shaderPicking;
+  }
+  clear() {
+    const color = rgb2arr(this.mapService.bgColor);
+    this.renderService.clear({
+      color,
+      depth: 1,
+      stencil: 0,
+      framebuffer: null
+    });
+  }
+  runRender() {
+    this.renderLayers();
+    this.layerRenderID = window.requestAnimationFrame(this.runRender.bind(this));
+  }
+  stopRender() {
+    window.cancelAnimationFrame(this.layerRenderID);
+  }
+}

package/lib/@antv/l7-core/es/services/layer/StyleAttribute.d.ts

@@ -0,0 +1,33 @@
+import type { IAttributeScale, IStyleAttribute, StyleScaleType } from '../layer/IStyleAttributeService';
+import type { IAttribute } from '../renderer/IAttribute';
+import type { AttributeType, IEncodeFeature, IFeatureRange, IStyleAttributeInitializationOptions, IVertexAttributeDescriptor } from './IStyleAttributeService';
+export default class StyleAttribute implements IStyleAttribute {
+    name: string;
+    type: AttributeType;
+    scale?: {
+        type: StyleScaleType.CONSTANT;
+        names: string[];
+        field: string | string[];
+        values: unknown[];
+        defaultValues: unknown[];
+        callback?: (...args: any[]) => [];
+        scalers?: IAttributeScale[];
+    };
+    descriptor: IVertexAttributeDescriptor;
+    featureBufferLayout: Array<{
+        feature: IEncodeFeature;
+        featureIdx: number;
+        bufferOffset: number;
+        length: number;
+    }>;
+    needRescale: boolean;
+    needRemapping: boolean;
+    needRegenerateVertices: boolean;
+    featureRange: IFeatureRange;
+    vertexAttribute: IAttribute;
+    constructor(options: Partial<IStyleAttributeInitializationOptions>);
+    setProps(options: Partial<IStyleAttributeInitializationOptions>): void;
+    mapping(params: unknown[]): unknown[];
+    resetDescriptor(): void;
+    private defaultCallback;
+}

package/lib/@antv/l7-core/es/services/layer/StyleAttribute.js

@@ -0,0 +1,63 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { lodashUtil } from '@antv/l7-utils';
+const {
+  isNil
+} = lodashUtil;
+export default class StyleAttribute {
+  constructor(options) {
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "scale", void 0);
+    _defineProperty(this, "descriptor", void 0);
+    _defineProperty(this, "featureBufferLayout", []);
+    _defineProperty(this, "needRescale", false);
+    _defineProperty(this, "needRemapping", false);
+    _defineProperty(this, "needRegenerateVertices", false);
+    _defineProperty(this, "featureRange", {
+      startIndex: 0,
+      endIndex: Infinity
+    });
+    _defineProperty(this, "vertexAttribute", void 0);
+    _defineProperty(this, "defaultCallback", params => {
+      // 没有 params 的情况，是指没有指定 fields，直接返回配置的 values 常量
+      if (params.length === 0) {
+        var _this$scale;
+        return ((_this$scale = this.scale) === null || _this$scale === void 0 ? void 0 : _this$scale.defaultValues) || [];
+      }
+      return params.map((param, idx) => {
+        var _this$scale2;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const scaleFunc = (_this$scale2 = this.scale) === null || _this$scale2 === void 0 ? void 0 : _this$scale2.scalers[idx].func;
+        // @ts-ignore // TODO 支持双变量映射
+        const value = scaleFunc(param);
+        return value;
+      });
+    });
+    this.setProps(options);
+  }
+  setProps(options) {
+    Object.assign(this, options);
+  }
+  mapping(params) {
+    var _this$scale3;
+    /**
+     * 当用户设置的 callback 返回 null 时, 应该返回默认 callback 中的值
+     */
+    if ((_this$scale3 = this.scale) !== null && _this$scale3 !== void 0 && _this$scale3.callback) {
+      var _this$scale4;
+      // 使用用户返回的值处理
+      const ret = (_this$scale4 = this.scale) === null || _this$scale4 === void 0 ? void 0 : _this$scale4.callback(...params);
+      if (!isNil(ret)) {
+        return [ret];
+      }
+    }
+
+    // 没有 callback 或者用户 callback 返回值为空，则使用默认的逻辑处理
+    return this.defaultCallback(params);
+  }
+  resetDescriptor() {
+    if (this.descriptor) {
+      this.descriptor.buffer.data = [];
+    }
+  }
+}

package/lib/@antv/l7-core/es/services/layer/StyleAttributeService.d.ts

@@ -0,0 +1,43 @@
+import type { IAttribute } from '../renderer/IAttribute';
+import type { IElements } from '../renderer/IElements';
+import type { IRendererService } from '../renderer/IRendererService';
+import type { ILayer } from './ILayerService';
+import type { IEncodeFeature, IScaleOptions, IStyleAttribute, IStyleAttributeInitializationOptions, IStyleAttributeService, IStyleAttributeUpdateOptions, Triangulation } from './IStyleAttributeService';
+/**
+ * 每个 Layer 都拥有一个，用于管理样式属性的注册和更新
+ */
+export default class StyleAttributeService implements IStyleAttributeService {
+    private readonly rendererService;
+    constructor(rendererService: IRendererService);
+    attributesAndIndices: {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+        elements: IElements;
+        count: number | null;
+    };
+    private attributes;
+    private triangulation;
+    private featureLayout;
+    registerStyleAttribute(options: Partial<IStyleAttributeInitializationOptions>): IStyleAttribute;
+    unRegisterStyleAttribute(name: string): void;
+    updateScaleAttribute(scaleOption: IScaleOptions): void;
+    updateStyleAttribute(attributeName: string, options: Partial<IStyleAttributeInitializationOptions>, updateOptions?: Partial<IStyleAttributeUpdateOptions>): void;
+    getLayerStyleAttributes(): IStyleAttribute[] | undefined;
+    getLayerStyleAttribute(attributeName: string): IStyleAttribute | undefined;
+    getLayerAttributeScale(name: string): unknown;
+    updateAttributeByFeatureRange(attributeName: string, features: IEncodeFeature[], startFeatureIdx?: number, endFeatureIdx?: number, layer?: ILayer): void;
+    createAttributesAndIndices(features: IEncodeFeature[], triangulation: Triangulation, styleOption: unknown, layer?: ILayer): {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+        elements: IElements;
+        count: number | null;
+    };
+    createAttributes(features: IEncodeFeature[], triangulation: Triangulation): {
+        attributes: {
+            [attributeName: string]: IAttribute;
+        };
+    };
+    clearAllAttributes(): void;
+}