@antv/l7-layers 2.25.7 → 2.25.9

package/lib/core/LayerPickService.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _l7Utils = require("@antv/l7-utils");
+class BaseLayerPickService {
+  constructor(layer) {
+    (0, _defineProperty2.default)(this, "layer", void 0);
+    this.layer = layer;
+  }
+  pickRender(target) {
+    const container = this.layer.getContainer();
+    const layerService = container.layerService;
+    const layer = this.layer;
+    // 瓦片图层的拾取绘制
+    if (layer.tileLayer) {
+      return layer.tileLayer.pickRender(target);
+    }
+    // 渲染瓦片图层的拾取
+    layer.hooks.beforePickingEncode.call();
+    layerService.renderTileLayerMask(layer);
+    layer.renderModels({
+      ispick: true
+    });
+    layer.hooks.afterPickingEncode.call();
+  }
+  pick(layer, target) {
+    var _this = this;
+    return (0, _asyncToGenerator2.default)(function* () {
+      const container = _this.layer.getContainer();
+      const pickingService = container.pickingService;
+      if (layer.type === 'RasterLayer') {
+        return _this.pickRasterLayer(layer, target);
+      }
+      _this.pickRender(target);
+      return pickingService.pickFromPickingFBO(layer, target);
+    })();
+  }
+  pickRasterLayer(layer, target, parent) {
+    const container = this.layer.getContainer();
+    const pickingService = container.pickingService;
+    const mapService = container.mapService;
+    // 当启用 enableRelativeCoordinates 时，使用 originalExtent 判断绝对坐标是否在范围内
+    const originalExtent = this.layer.getOriginalExtent();
+    const extent = originalExtent[0] !== 0 || originalExtent[2] !== 0 ? originalExtent : this.layer.getSource().extent;
+    const isPick = (0, _l7Utils.lngLatInExtent)(target.lngLat, extent);
+    const layerTarget = {
+      x: target.x,
+      y: target.y,
+      type: target.type,
+      lngLat: target.lngLat,
+      target,
+      rasterValue: null
+    };
+    const adviceTarget = parent ? parent : layer;
+    if (isPick) {
+      const rasterValue = this.readRasterValue(layer, extent, mapService, target.x, target.y);
+      layerTarget.rasterValue = rasterValue;
+      pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
+      return true;
+    } else {
+      layerTarget.type = target.type === 'mousemove' ? 'mouseout' : 'un' + target.type;
+      pickingService.triggerHoverOnLayer(adviceTarget, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, layerTarget), {}, {
+        type: 'unpick'
+      }));
+      pickingService.triggerHoverOnLayer(adviceTarget, layerTarget);
+      return false;
+    }
+  }
+  readRasterValue(layer, bbox, mapService, x, y) {
+    const rasterData = layer.getSource().data.dataArray[0];
+    const [minLng = 0, minLat = 0, maxLng = 10, maxLat = -10] = bbox;
+    const tileXY = mapService.lngLatToContainer([minLng, minLat]);
+    const tileMaxXY = mapService.lngLatToContainer([maxLng, maxLat]);
+    const tilePixelWidth = tileMaxXY.x - tileXY.x;
+    const tilePixelHeight = tileXY.y - tileMaxXY.y;
+    const pos = [(x - tileXY.x) / tilePixelWidth,
+    // x
+    (y - tileMaxXY.y) / tilePixelHeight // y
+    ];
+    const tileWidth = rasterData.width || 1;
+    const tileHeight = rasterData.height || 1;
+    const indexX = Math.floor(pos[0] * tileWidth);
+    const indexY = Math.floor(pos[1] * tileHeight);
+    const index = Math.max(0, indexY - 1) * tileWidth + indexX;
+    const data = rasterData.data[index];
+    return data;
+  }
+  selectFeature(pickedColors) {
+    const layer = this.layer;
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    layer.hooks.beforeSelect.call([r, g, b]);
+  }
+  highlightPickedFeature(pickedColors) {
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    this.layer.hooks.beforeHighlight.call([r, g, b]);
+  }
+  getFeatureById(pickedFeatureIdx) {
+    return this.layer.getSource().getFeatureById(pickedFeatureIdx);
+  }
+}
+exports.default = BaseLayerPickService;

package/lib/core/TextureService.d.ts

@@ -0,0 +1,15 @@
+import type { ILayer, ITexture2D, ITextureService } from '@antv/l7-core';
+import type { IColorRamp } from '@antv/l7-utils';
+export default class TextureService implements ITextureService {
+    private layer;
+    private rendererService;
+    private colorTexture;
+    private key;
+    constructor(layer: ILayer);
+    getColorTexture(colorRamp: IColorRamp, domain?: [number, number]): ITexture2D;
+    createColorTexture(colorRamp: IColorRamp, domain?: [number, number]): ITexture2D;
+    setColorTexture(texture: ITexture2D, colorRamp: IColorRamp, domain: [number, number]): void;
+    destroy(): void;
+    private getColorRampBar;
+    private getTextureKey;
+}

package/lib/core/TextureService.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _l7Utils = require("@antv/l7-utils");
+class TextureService {
+  constructor(layer) {
+    (0, _defineProperty2.default)(this, "layer", void 0);
+    (0, _defineProperty2.default)(this, "rendererService", void 0);
+    (0, _defineProperty2.default)(this, "colorTexture", void 0);
+    (0, _defineProperty2.default)(this, "key", void 0);
+    this.layer = layer;
+    const container = this.layer.getContainer();
+    this.rendererService = container.rendererService;
+  }
+  getColorTexture(colorRamp, domain) {
+    // TODO 支持传入图片
+    const currentkey = this.getTextureKey(colorRamp, domain);
+    if (this.key === currentkey) {
+      return this.colorTexture;
+    } else {
+      this.createColorTexture(colorRamp, domain);
+    }
+    this.key = currentkey;
+    return this.colorTexture;
+  }
+  createColorTexture(colorRamp, domain) {
+    const {
+      createTexture2D
+    } = this.rendererService;
+    const imageData = this.getColorRampBar(colorRamp, domain);
+    const texture = createTexture2D({
+      data: new Uint8Array(imageData.data),
+      width: imageData.width,
+      height: imageData.height,
+      flipY: false,
+      unorm: true
+    });
+    this.colorTexture = texture;
+    return texture;
+  }
+  setColorTexture(texture, colorRamp, domain) {
+    this.key = this.getTextureKey(colorRamp, domain);
+    this.colorTexture = texture;
+  }
+  destroy() {
+    var _this$colorTexture;
+    (_this$colorTexture = this.colorTexture) === null || _this$colorTexture === void 0 || _this$colorTexture.destroy();
+  }
+  getColorRampBar(colorRamp, domain) {
+    switch (colorRamp.type) {
+      case 'cat':
+        return (0, _l7Utils.generateCatRamp)(colorRamp);
+      case 'quantize':
+        return (0, _l7Utils.generateQuantizeRamp)(colorRamp);
+      case 'custom':
+        return (0, _l7Utils.generateCustomRamp)(colorRamp, domain);
+      case 'linear':
+        return (0, _l7Utils.generateLinearRamp)(colorRamp, domain);
+      default:
+        return (0, _l7Utils.generateColorRamp)(colorRamp);
+    }
+  }
+  getTextureKey(colorRamp, domain) {
+    var _colorRamp$positions;
+    return `${colorRamp.colors.join('_')}_${colorRamp === null || colorRamp === void 0 || (_colorRamp$positions = colorRamp.positions) === null || _colorRamp$positions === void 0 ? void 0 : _colorRamp$positions.join('_')}_${colorRamp.type}_${domain === null || domain === void 0 ? void 0 : domain.join('_')}`;
+  }
+}
+exports.default = TextureService;

package/lib/core/constant.d.ts

@@ -0,0 +1,6 @@
+export declare const DefaultUniformStyleValue: {
+    [key: string]: any;
+};
+export declare const DefaultUniformStyleType: {
+    [key: string]: any;
+};

package/lib/core/constant.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DefaultUniformStyleValue = exports.DefaultUniformStyleType = void 0;
+const DefaultUniformStyleValue = exports.DefaultUniformStyleValue = {
+  opacity: 1,
+  stroke: [1, 0, 0, 1],
+  offsets: [0, 0],
+  rotation: 0,
+  extrusionBase: 0,
+  strokeOpacity: 1,
+  thetaOffset: 0.314
+};
+const DefaultUniformStyleType = exports.DefaultUniformStyleType = {
+  opacity: 'float',
+  stroke: 'vec4',
+  offsets: 'vec2',
+  textOffset: 'vec2',
+  rotation: 'float',
+  extrusionBase: 'float',
+  strokeOpacity: 'float',
+  thetaOffset: 'float'
+};

package/lib/core/interface.d.ts

@@ -0,0 +1,284 @@
+import type { IAnimateOption, IMapService, ITexture2D, StyleAttributeField, StyleAttributeOption } from '@antv/l7-core';
+import type { IColorRamp } from '@antv/l7-utils';
+import type { CanvasModelType } from '../canvas/models';
+import type { anchorType } from '../utils/symbol-layout';
+export declare enum lineStyleType {
+    'solid' = 0,
+    'dash' = 1
+}
+export declare enum LinearDir {
+    VERTICAL = "vertical",
+    HORIZONTAL = "horizontal"
+}
+export declare enum TextureBlend {
+    NORMAL = "normal",
+    REPLACE = "replace"
+}
+/**
+ * 基础图层类型定义
+ */
+export interface IBaseLayerStyleOptions {
+    opacity?: number;
+    depth?: boolean;
+    blend?: string;
+    raisingHeight?: number;
+    heightfixed?: boolean;
+    zIndex?: number;
+    mask?: boolean;
+    maskInside?: boolean;
+    enableRelativeCoordinates?: boolean;
+    color?: string;
+    size?: number;
+}
+export interface ILineLayerStyleOptions extends IBaseLayerStyleOptions {
+    relativeOrigin?: number[];
+    coord?: string;
+    lineType?: keyof typeof lineStyleType;
+    dashArray?: [number, number];
+    segmentNumber?: number;
+    forward?: boolean;
+    lineTexture?: boolean;
+    iconStep?: number;
+    iconStepCount?: number;
+    textureBlend?: TextureBlend;
+    linearDir?: LinearDir;
+    sourceColor?: string;
+    targetColor?: string;
+    thetaOffset?: number;
+    globalArcHeight?: number;
+    vertexHeightScale?: number;
+    borderWidth?: number;
+    borderColor?: string;
+    strokeWidth?: number;
+    storke?: string;
+    blur?: [number, number, number];
+    symbol?: ILineSymbol;
+    rampColors?: IColorRamp;
+    featureId?: string;
+    sourceLayer?: string;
+    enablePicking?: boolean;
+    workerEnabled?: boolean;
+}
+export declare enum SizeUnitType {
+    pixel = 0,
+    meter = 1
+}
+export interface IPointLayerStyleOptions extends IBaseLayerStyleOptions {
+    relativeOrigin?: number[];
+    coord?: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    stroke: string;
+    blur?: number;
+    billboard?: boolean;
+    textOffset?: [number, number];
+    textAnchor?: anchorType;
+    spacing?: number;
+    padding?: [number, number];
+    halo?: number;
+    gamma?: number;
+    fontWeight?: string;
+    fontFamily?: string;
+    textAllowOverlap?: boolean;
+    allowOverlap?: boolean;
+    pickLight?: boolean;
+    sourceColor?: string;
+    targetColor?: string;
+    opacityLinear?: {
+        enable: boolean;
+        dir: string;
+    };
+    lightEnable: boolean;
+    offsets?: [number, number];
+    unit?: SizeUnitType;
+    rotation?: number;
+    speed?: number;
+    featureId?: string;
+    sourceLayer?: string;
+}
+export interface IPolygonLayerStyleOptions extends IBaseLayerStyleOptions {
+    relativeOrigin?: number[];
+    coord?: string;
+    opacityLinear?: {
+        enable: boolean;
+        dir: string;
+    };
+    topsurface?: boolean;
+    sidesurface?: boolean;
+    mapTexture?: string;
+    sourceColor?: string;
+    targetColor?: string;
+    pickLight: boolean;
+    waterTexture?: string;
+    speed?: number;
+    watercolor?: string;
+    watercolor2?: string;
+    featureId?: string;
+    sourceLayer?: string;
+}
+export interface IPolygonExtrusionStyleOptions {
+    opacity: number;
+    extrusionBase: number;
+}
+export interface IRasterTileLayerStyleOptions extends IBaseLayerStyleOptions {
+    opacity: number;
+}
+export interface IMaskLayerStyleOptions extends IBaseLayerStyleOptions {
+    opacity: number;
+    color: string;
+    sourceLayer?: string;
+}
+export interface IWindLayerStyleOptions extends IBaseLayerStyleOptions {
+    uMin?: number;
+    uMax?: number;
+    vMin?: number;
+    vMax?: number;
+    fadeOpacity?: number;
+    speedFactor?: number;
+    dropRate?: number;
+    dropRateBump?: number;
+    numParticles?: number;
+    rampColors?: {
+        [key: number]: string;
+    };
+    sizeScale?: number;
+}
+export interface IImageLayerStyleOptions extends IBaseLayerStyleOptions {
+    domain?: [number, number];
+    noDataValue?: number;
+    clampLow?: boolean;
+    clampHigh?: boolean;
+    rampColors?: IColorRamp;
+    colorTexture?: ITexture2D;
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    gamma?: number;
+}
+export interface ICityBuildLayerStyleOptions {
+    opacity: number;
+    baseColor: string;
+    brightColor: string;
+    windowColor: string;
+    time: number;
+    sweep: {
+        enable: boolean;
+        sweepRadius: number;
+        sweepColor: string;
+        sweepSpeed: number;
+        sweepCenter?: [number, number];
+    };
+}
+export interface IGeometryLayerStyleOptions extends IBaseLayerStyleOptions {
+    mapTexture?: string;
+    terrainTexture?: string;
+    center?: [number, number];
+    width?: number;
+    height?: number;
+    widthSegments?: number;
+    heightSegments?: number;
+    terrainClipHeight?: number;
+    rgb2height?: (r: number, g: number, b: number) => number;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    drawCanvas?: (canvas: HTMLCanvasElement) => void;
+    spriteAnimate?: string;
+    spriteRadius?: number;
+    spriteCount?: number;
+    spriteSpeed?: number;
+    spriteTop?: number;
+    spriteBottom?: number;
+    spriteUpdate?: number;
+    spriteScale?: number;
+    animateOption?: IAnimateOption;
+}
+export declare enum CanvasUpdateType {
+    'ALWAYS' = "always",
+    'DRAGEND' = "dragend"
+}
+export interface IDrawingOnCanvas {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    mapService: IMapService;
+    size: [number, number];
+}
+export interface ICanvasLayerRenderParams {
+    canvas: HTMLCanvasElement;
+    ctx: RenderingContext;
+    container: {
+        width: number;
+        height: number;
+        bounds: [[number, number], [number, number]];
+    };
+    size: [number, number];
+    utils: {
+        lngLatToContainer: IMapService['lngLatToContainer'];
+    };
+    mapService: IMapService;
+}
+export interface ICanvasLayerOptions {
+    zIndex?: number;
+    contextType?: CanvasModelType;
+    getContext?: (canvas: HTMLCanvasElement) => RenderingContext;
+    trigger?: 'end' | 'change';
+    /**
+     * @deprecated
+     * @alias trigger
+     */
+    update?: CanvasUpdateType | string;
+    draw?: (renderParams: ICanvasLayerRenderParams) => void;
+    /**
+     * @deprecated
+     * @alias draw
+     */
+    drawingOnCanvas?: (renderParams: ICanvasLayerRenderParams) => void;
+}
+export interface IHeatMapLayerStyleOptions extends IBaseLayerStyleOptions {
+    intensity: number;
+    radius: number;
+    angle: number;
+    rampColors: IColorRamp;
+    coverage?: number;
+}
+export interface IBaseRasterLayerStyleOptions extends IBaseLayerStyleOptions {
+    colorTexture?: ITexture2D;
+    domain: [number, number];
+    noDataValue: number;
+    clampLow: boolean;
+    clampHigh: boolean;
+    rampColors: IColorRamp;
+}
+export interface IRasterLayerStyleOptions extends IBaseRasterLayerStyleOptions {
+    channelRMax?: number;
+    channelGMax?: number;
+    channelBMax?: number;
+}
+export interface IRasterTerrainLayerStyleOptions extends IBaseRasterLayerStyleOptions {
+    rScaler?: number;
+    gScaler?: number;
+    bScaler?: number;
+    offset?: number;
+}
+export type ArrowType = 'circle' | 'triangle' | 'rect' | 'diamond' | 'classic' | 'halfTriangle' | 'none';
+export interface IArrowOptions {
+    type: ArrowType;
+    width?: number;
+    height?: number;
+    radius?: number;
+}
+export interface ILineSymbol {
+    source: ArrowType | IArrowOptions;
+    target: ArrowType | IArrowOptions;
+}
+export interface IFlowLineStyleOptions extends IBaseLayerStyleOptions {
+    gapWidth?: number;
+    offsets?: [number, number];
+    stroke?: string;
+    strokeOpacity?: number;
+    strokeWidth?: number;
+    symbol?: ILineSymbol;
+}
+export interface IStyleEncodeAttributeOptions {
+    field: StyleAttributeField;
+    values?: StyleAttributeOption;
+}

package/lib/core/interface.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lineStyleType = exports.TextureBlend = exports.SizeUnitType = exports.LinearDir = exports.CanvasUpdateType = void 0;
+let lineStyleType = exports.lineStyleType = /*#__PURE__*/function (lineStyleType) {
+  lineStyleType[lineStyleType["solid"] = 0] = "solid";
+  lineStyleType[lineStyleType["dash"] = 1] = "dash";
+  return lineStyleType;
+}({});
+let LinearDir = exports.LinearDir = /*#__PURE__*/function (LinearDir) {
+  LinearDir["VERTICAL"] = "vertical";
+  LinearDir["HORIZONTAL"] = "horizontal";
+  return LinearDir;
+}({});
+let TextureBlend = exports.TextureBlend = /*#__PURE__*/function (TextureBlend) {
+  TextureBlend["NORMAL"] = "normal";
+  TextureBlend["REPLACE"] = "replace";
+  return TextureBlend;
+}({});
+/**
+ * 基础图层类型定义
+ */
+let SizeUnitType = exports.SizeUnitType = /*#__PURE__*/function (SizeUnitType) {
+  SizeUnitType[SizeUnitType["pixel"] = 0] = "pixel";
+  SizeUnitType[SizeUnitType["meter"] = 1] = "meter";
+  return SizeUnitType;
+}({}); // 栅格瓦片图层
+let CanvasUpdateType = exports.CanvasUpdateType = /*#__PURE__*/function (CanvasUpdateType) {
+  CanvasUpdateType["ALWAYS"] = "always";
+  CanvasUpdateType["DRAGEND"] = "dragend";
+  return CanvasUpdateType;
+}({});

package/lib/core/line_trangluation.d.ts

@@ -0,0 +1,19 @@
+import type { IEncodeFeature } from '@antv/l7-core';
+export declare function FlowHalfArrowFillTriangulation(feature: IEncodeFeature): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function FlowLineTriangulation(feature: IEncodeFeature, symbolOption?: unknown): {
+    vertices: number[];
+    normals: number[];
+    indices: number[];
+    size: number;
+};
+export declare function ArrowLineTriangulation(feature: IEncodeFeature, symbolOption?: unknown): {
+    vertices: number[];
+    indices: number[];
+    normals: number[];
+    size: number;
+};

package/lib/core/line_trangluation.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowLineTriangulation = ArrowLineTriangulation;
+exports.FlowHalfArrowFillTriangulation = FlowHalfArrowFillTriangulation;
+exports.FlowLineTriangulation = FlowLineTriangulation;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _arrow = require("./shape/arrow");
+// list all arrow shape
+
+// Half Edge
+function FlowHalfArrowFillTriangulation(feature) {
+  // @ts-ignore
+  const coord = feature.coordinates.flat();
+  const tin = 1;
+  const tout = 1.0;
+  return {
+    vertices: [1, 0, 0, ...coord,
+    // 0
+    1, 2, -3, ...coord,
+    // 1
+    1, 1, -3, ...coord,
+    // 2
+    0, 1, 0, ...coord,
+    // 3
+    0, 0, 0, ...coord,
+    // 4
+    1, 0, 0, ...coord,
+    // 0
+    1, 2, -3, ...coord,
+    // 1
+    1, 1, -3, ...coord,
+    // 2
+    0, 1, 0, ...coord,
+    // 3
+    0, 0, 0, ...coord // 4
+    ],
+    normals: [-tin, 2 * tout, 1,
+    // 0
+    2 * tout, -tout, 1,
+    // 1
+    tout, -tout, 1,
+    // 2
+    tout, -tout, 1,
+    // 3
+    -tin, -tout, 1,
+    // 4
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    indices: [0, 1, 2, 0, 2, 3, 0, 3, 4, 5, 6, 7, 5, 7, 8, 5, 8, 9],
+    size: 7
+  };
+}
+function FlowLineTriangulation(feature, symbolOption) {
+  return symbolOption ? ArrowLineTriangulation(feature, symbolOption) : FlowHalfArrowFillTriangulation(feature);
+}
+function ArrowLineTriangulation(feature, symbolOption) {
+  // @ts-ignore
+  const coord = feature.coordinates.flat();
+  const {
+    target = 'classic',
+    source = 'circle'
+  } = symbolOption;
+  const startSymbol = shape2Vertices((0, _arrow.getSymbol)(source, 'source'), coord, 0, 0);
+  const linePath = (0, _arrow.lineArrowPath)(coord, startSymbol.vertices.length / 7, symbolOption);
+  const endSymbol = shape2Vertices((0, _arrow.getSymbol)(target, 'target'), coord, 1, startSymbol.vertices.length / 7 + linePath.vertices.length / 7);
+  const data = {
+    vertices: [...startSymbol.vertices, ...linePath.vertices, ...endSymbol.vertices],
+    indices: [...startSymbol.outLineIndices, ...linePath.outLineIndices, ...endSymbol.outLineIndices, ...startSymbol.indices, ...linePath.indices, ...endSymbol.indices],
+    normals: [...startSymbol.normals, ...linePath.normals, ...endSymbol.normals],
+    size: 7
+  };
+  return data;
+}
+// start 0,end 1;
+function shape2Vertices(shape, coord, type = 1, indexOffset = 0) {
+  const shapeVertices = [];
+  const {
+    vertices,
+    indices,
+    dimensions,
+    outLineIndices
+  } = shape;
+  for (let i = 0; i < vertices.length; i += dimensions) {
+    shapeVertices.push(type, vertices[i + 1], vertices[i], ...coord);
+  }
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, shape), {}, {
+    vertices: shapeVertices,
+    indices: indices.map(i => i + indexOffset),
+    outLineIndices: outLineIndices.map(i => i + indexOffset)
+  });
+}

package/lib/core/schema.d.ts

@@ -0,0 +1,27 @@
+/**
+ * BaseLayer Schema
+ */
+declare const _default: {
+    properties: {
+        enablePicking: {
+            type: string;
+        };
+        enableHighlight: {
+            type: string;
+        };
+        highlightColor: {
+            oneOf: ({
+                type: string;
+                items: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            } | {
+                type: string;
+                items?: undefined;
+            })[];
+        };
+    };
+};
+export default _default;