@antv/l7-layers 2.10.2 → 2.10.4

package/es/tile/tileFactory/base.js

@@ -0,0 +1,403 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import Source from '@antv/l7-source';
+import { setStyleAttributeField, setScale } from "../style/utils";
+import { registerLayers } from "../utils";
+import { readRasterValue } from "../interaction/getRasterData";
+import VectorLayer from "./layers/vectorLayer";
+import * as turf from '@turf/helpers';
+import union from '@turf/union';
+import clone from '@turf/clone';
+import polygonToLineString from '@turf/polygon-to-line';
+var EMPTY_FEATURE_DATA = {
+  features: [],
+  featureId: null,
+  vectorTileLayer: null,
+  source: null
+};
+
+var TileFactory = /*#__PURE__*/function () {
+  // 用于记录图层内事件，辅助判断图层外事件逻辑
+  function TileFactory(option) {
+    _classCallCheck(this, TileFactory);
+
+    _defineProperty(this, "outSideEventTimer", null);
+
+    _defineProperty(this, "eventCache", {
+      click: 0,
+      mousemove: 0,
+      mouseup: 0,
+      mousedown: 0,
+      contextmenu: 0
+    });
+
+    this.parentLayer = option.parent;
+    this.mapService = option.mapService;
+    this.rendererService = option.rendererService;
+    var source = this.parentLayer.getSource();
+    this.zoomOffset = source.parser.zoomOffset || 0;
+    this.tilesetManager = source.tileset;
+  } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+  _createClass(TileFactory, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      return {
+        layers: [],
+        layerIDList: []
+      };
+    }
+  }, {
+    key: "getFeatureData",
+    value: function getFeatureData(tile, initOptions) {
+      var sourceLayer = initOptions.sourceLayer,
+          featureId = initOptions.featureId,
+          _initOptions$transfor = initOptions.transforms,
+          transforms = _initOptions$transfor === void 0 ? [] : _initOptions$transfor,
+          layerType = initOptions.layerType,
+          shape = initOptions.shape;
+
+      if (!sourceLayer) {
+        return EMPTY_FEATURE_DATA;
+      }
+
+      var vectorTileLayer = tile.data.layers[sourceLayer];
+      var features = vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.features;
+
+      if (!(Array.isArray(features) && features.length > 0)) {
+        return EMPTY_FEATURE_DATA;
+      } else {
+        var geofeatures = [];
+
+        if (layerType === 'LineLayer' && shape === 'simple') {
+          features.map(function (feature) {
+            var cloneFeature = clone(feature);
+
+            if (cloneFeature.geometry.type === 'MultiPolygon') {
+              var _geofeatures;
+
+              // @ts-ignore
+              var linefeatures = polygonToLineString(cloneFeature).features;
+
+              (_geofeatures = geofeatures).push.apply(_geofeatures, _toConsumableArray(linefeatures));
+            } else if (cloneFeature.geometry.type === 'Polygon') {
+              cloneFeature.geometry.type = 'MultiLineString';
+              geofeatures.push(cloneFeature);
+            } else {
+              geofeatures.push(cloneFeature);
+            }
+          });
+        } else {
+          geofeatures = features;
+        }
+
+        var source = new Source({
+          type: 'FeatureCollection',
+          features: geofeatures
+        }, {
+          parser: {
+            type: 'geojson',
+            featureId: featureId,
+            cancelExtent: true
+          },
+          transforms: transforms
+        });
+        return {
+          features: geofeatures,
+          featureId: featureId,
+          vectorTileLayer: vectorTileLayer,
+          source: source
+        };
+      }
+    }
+  }, {
+    key: "createLayer",
+    value: function createLayer(tileLayerOption) {
+      var L7Layer = tileLayerOption.L7Layer,
+          tile = tileLayerOption.tile,
+          initOptions = tileLayerOption.initOptions,
+          vectorTileLayer = tileLayerOption.vectorTileLayer,
+          source = tileLayerOption.source,
+          _tileLayerOption$need = tileLayerOption.needListen,
+          needListen = _tileLayerOption$need === void 0 ? true : _tileLayerOption$need;
+      var mask = initOptions.mask,
+          color = initOptions.color,
+          layerType = initOptions.layerType,
+          size = initOptions.size,
+          shape = initOptions.shape,
+          usage = initOptions.usage,
+          basemapColor = initOptions.basemapColor,
+          basemapSize = initOptions.basemapSize;
+      var FactoryTileLayer = L7Layer ? L7Layer : VectorLayer;
+      var layer = new FactoryTileLayer(_objectSpread({
+        visible: tile.isVisible,
+        tileOrigin: vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.l7TileOrigin,
+        coord: vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.l7TileCoord,
+        needListen: needListen
+      }, this.getLayerInitOption(initOptions)));
+      if (layerType) layer.type = layerType; // Tip: sign tile layer
+
+      layer.isTileLayer = true; // vector 、raster
+      // vector layer set event
+
+      if (layer.isVector && usage !== 'basemap') {
+        this.emitEvent([layer]);
+        layer.select(true);
+      } // set source
+
+
+      layer.source(source); // set scale attribute field
+
+      setStyleAttributeField(layer, this.parentLayer, 'shape', shape);
+
+      if (usage !== 'basemap') {
+        // set scale
+        setScale(layer, this.parentLayer);
+        setStyleAttributeField(layer, this.parentLayer, 'color', color);
+        setStyleAttributeField(layer, this.parentLayer, 'size', size);
+      } else {
+        layer.style({
+          color: basemapColor,
+          size: basemapSize
+        });
+      } // set mask
+
+
+      if (mask && layer.isVector) {
+        var masklayer = new VectorLayer({
+          layerType: "MaskLayer"
+        }).source({
+          type: 'FeatureCollection',
+          features: [tile.bboxPolygon]
+        }, {
+          parser: {
+            type: 'geojson',
+            cancelExtent: true
+          }
+        });
+        registerLayers(this.parentLayer, [masklayer]);
+        layer.addMaskLayer(masklayer);
+      }
+
+      this.layers = [layer];
+      return layer;
+    } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+  }, {
+    key: "updateStyle",
+    value: function updateStyle(styles) {
+      return '';
+    }
+  }, {
+    key: "getTile",
+    value: function getTile(lng, lat) {
+      var zoom = this.mapService.getZoom();
+      return this.tilesetManager.getTileByLngLat(lng, lat, zoom);
+    }
+  }, {
+    key: "bindVectorEvent",
+    value: function bindVectorEvent(layer) {
+      var _this = this;
+
+      layer.on('click', function (e) {
+        _this.eventCache.click = 1;
+
+        _this.getFeatureAndEmitEvent('subLayerClick', e);
+      });
+      layer.on('mousemove', function (e) {
+        _this.eventCache.mousemove = 1;
+
+        _this.getFeatureAndEmitEvent('subLayerMouseMove', e);
+      });
+      layer.on('mouseenter', function (e) {
+        _this.getFeatureAndEmitEvent('subLayerMouseEnter', e);
+      });
+    }
+  }, {
+    key: "readRasterTile",
+    value: function readRasterTile(e, name) {
+      var _e$lngLat = e.lngLat,
+          lng = _e$lngLat.lng,
+          lat = _e$lngLat.lat;
+      var tile = this.getTile(lng, lat);
+      if (!tile) return;
+      var data = readRasterValue(tile, this.mapService, e.x, e.y);
+      e.value = data;
+      this.parentLayer.emit(name, e);
+    }
+  }, {
+    key: "bindRasterEvent",
+    value: function bindRasterEvent(layer) {
+      var _this2 = this;
+
+      layer.on('click', function (e) {
+        _this2.eventCache.click = 1;
+
+        _this2.readRasterTile(e, 'subLayerClick');
+      });
+      layer.on('mousemove', function (e) {
+        _this2.eventCache.mousemove = 1;
+
+        _this2.readRasterTile(e, 'subLayerMouseMove');
+      });
+      layer.on('mouseenter', function (e) {
+        _this2.readRasterTile(e, 'subLayerMouseMove');
+      });
+    }
+  }, {
+    key: "bindCommonEvent",
+    value: function bindCommonEvent(layer) {
+      var _this3 = this;
+
+      layer.on('mouseup', function (e) {
+        _this3.eventCache.mouseup = 1;
+
+        _this3.getFeatureAndEmitEvent('subLayerMouseUp', e);
+      });
+      layer.on('mouseout', function (e) {
+        _this3.getFeatureAndEmitEvent('subLayerMouseOut', e);
+      });
+      layer.on('mousedown', function (e) {
+        _this3.eventCache.mousedown = 1;
+
+        _this3.getFeatureAndEmitEvent('subLayerMouseDown', e);
+      });
+      layer.on('contextmenu', function (e) {
+        _this3.eventCache.contextmenu = 1;
+
+        _this3.getFeatureAndEmitEvent('subLayerContextmenu', e);
+      }); // out side
+
+      layer.on('unclick', function (e) {
+        return _this3.handleOutsideEvent('click', 'subLayerUnClick', layer, e);
+      });
+      layer.on('unmouseup', function (e) {
+        return _this3.handleOutsideEvent('mouseup', 'subLayerUnMouseUp', layer, e);
+      });
+      layer.on('unmousedown', function (e) {
+        return _this3.handleOutsideEvent('mousedown', 'subLayerUnMouseDown', layer, e);
+      });
+      layer.on('uncontextmenu', function (e) {
+        return _this3.handleOutsideEvent('contextmenu', 'subLayerUnContextmenu', layer, e);
+      });
+    }
+  }, {
+    key: "emitEvent",
+    value: function emitEvent(layers) {
+      var _this4 = this;
+
+      layers.map(function (layer) {
+        layer.once('modelLoaded', function () {
+          _this4.bindVectorEvent(layer);
+
+          _this4.bindCommonEvent(layer);
+        });
+      });
+    }
+  }, {
+    key: "emitRasterEvent",
+    value: function emitRasterEvent(layers) {
+      var _this5 = this;
+
+      layers.map(function (layer) {
+        layer.once('modelLoaded', function () {
+          _this5.bindRasterEvent(layer);
+
+          _this5.bindCommonEvent(layer);
+        });
+      });
+    }
+  }, {
+    key: "getCombineFeature",
+    value: function getCombineFeature(features) {
+      var p = null;
+      var properties = features[0];
+      features.map(function (feature) {
+        var polygon = turf.polygon(feature.coordinates);
+
+        if (p === null) {
+          p = polygon;
+        }
+
+        {
+          p = union(p, polygon);
+        }
+      });
+
+      if (properties) {
+        p.properties = _objectSpread({}, properties);
+      }
+
+      return p;
+    }
+  }, {
+    key: "getFeatureAndEmitEvent",
+    value: function getFeatureAndEmitEvent(eventName, e) {
+      var featureId = e.featureId;
+      var features = this.getAllFeatures(featureId);
+
+      try {
+        e.feature = this.getCombineFeature(features);
+      } catch (err) {
+        console.warn('Combine Featuer Err! Return First Feature!');
+        e.feature = features[0];
+      }
+
+      this.parentLayer.emit(eventName, e);
+    }
+  }, {
+    key: "getAllFeatures",
+    value: function getAllFeatures(featureId) {
+      var allLayers = this.parentLayer.tileLayer.children;
+      var features = [];
+      allLayers.map(function (layer) {
+        var source = layer.getSource();
+        source.data.dataArray.map(function (feature) {
+          if (feature._id === featureId) {
+            features.push(feature);
+          }
+        });
+      });
+      return features;
+    }
+  }, {
+    key: "getLayerInitOption",
+    value: function getLayerInitOption(initOptions) {
+      var option = _objectSpread({}, initOptions);
+
+      delete option.color;
+      delete option.shape;
+      delete option.size;
+      delete option.coords;
+      delete option.sourceLayer;
+      delete option.coords;
+      return option;
+    }
+  }, {
+    key: "handleOutsideEvent",
+    value: function handleOutsideEvent(type, emitType, layer, e) {
+      var _this6 = this;
+
+      if (this.outSideEventTimer) {
+        clearTimeout(this.outSideEventTimer);
+        this.outSideEventTimer = null;
+      }
+
+      this.outSideEventTimer = setTimeout(function () {
+        if (_this6.eventCache[type] > 0) {
+          _this6.eventCache[type] = 0;
+        } else {
+          _this6.getFeatureAndEmitEvent(emitType, e);
+        }
+      }, 64);
+    }
+  }]);
+
+  return TileFactory;
+}();
+
+export { TileFactory as default };

package/es/tile/tileFactory/index.d.ts

@@ -1,11 +1,5 @@
-import { ILayer } from '@antv/l7-core';
-import VectorTile from './VectorTile';
-import DebugTile from './DebugTile';
-import ImageTile from './ImageTile';
-import RasterTile from './RasterTile';
-import RasterRGBTile from './RasterRGBTile';
-import MaskLayer from './MaskTile';
-export declare type TileType = 'VectorTile' | 'DebugTile' | 'PolygonLayer' | 'PointLayer' | 'LineLayer' | 'RasterLayer' | 'image' | 'MaskLayer' | 'TileDebugLayer';
-export declare function getTileFactory(layer: ILayer): typeof VectorTile | typeof DebugTile | typeof ImageTile | typeof RasterTile | typeof RasterRGBTile | typeof MaskLayer;
+import { IParserCfg } from '@antv/l7-core';
+import VectorLineTile from './line';
+export declare type TileType = 'PolygonLayer' | 'PointLayer' | 'LineLayer' | 'RasterLayer' | 'MaskLayer' | 'TileDebugLayer';
+export declare function getTileFactory(tileType: TileType, parser: IParserCfg): typeof VectorLineTile;
 export * from '../interface';
-export * from './Tile';

package/es/tile/tileFactory/index.js

@@ -1,45 +1,38 @@
-import VectorTile from "./VectorTile";
-import DebugTile from "./DebugTile";
-import ImageTile from "./ImageTile";
-import RasterTile from "./RasterTile";
-import RasterRGBTile from "./RasterRGBTile";
-import MaskLayer from "./MaskTile";
-export function getTileFactory(layer) {
-  var tileType = layer.type;
-
+import { rasterDataTypes } from '@antv/l7-source';
+import VectorLineTile from "./line";
+import VectorPointLayer from "./point";
+import VectorPolygonTile from "./polygon";
+import VectorMask from "./mask";
+import RasterTileFactory from "./raster";
+import RasterDataFactory from "./rasterData";
+import TestTile from "./test";
+export function getTileFactory(tileType, parser) {
   switch (tileType) {
     case 'PolygonLayer':
-      return VectorTile;
+      return VectorPolygonTile;
 
     case 'LineLayer':
-      return VectorTile;
+      return VectorLineTile;
 
     case 'PointLayer':
-      return VectorTile;
-
-    case 'TileDebugLayer':
-      return DebugTile;
+      return VectorPointLayer;
 
     case 'MaskLayer':
-      return MaskLayer;
-
-    case 'RasterLayer':
-      var dataType = layer.getSource().parser.dataType;
-
-      switch (dataType) {
-        case 'rgb':
-          return RasterRGBTile;
+      return VectorMask;
 
-        case 'arraybuffer':
-          return RasterTile;
+    case 'TileDebugLayer':
+      return TestTile;
 
-        default:
-          return ImageTile;
+    case 'RasterLayer':
+      if (rasterDataTypes.includes(parser.dataType)) {
+        return RasterDataFactory;
+      } else {
+        return RasterTileFactory;
       }
 
     default:
-      return VectorTile;
+      console.warn('Current Tile Not Exist!');
+      return RasterTileFactory;
   }
 }
-export * from "../interface";
-export * from "./Tile";
+export * from "../interface";

package/es/tile/tileFactory/layers/{RasterDataLayer.d.ts → rasterDataLayer.d.ts}

@@ -4,8 +4,8 @@ import RasterModel from '../../../raster/models/rasterTile';
 import RasterRgbModel from '../../../raster/models/rasterRgb';
 export default class RasterTiffLayer extends BaseLayer<Partial<IRasterLayerStyleOptions>> {
     type: string;
-    buildModels(): Promise<void>;
-    getModel(): typeof RasterRgbModel | typeof RasterModel;
-    getModelType(): string;
+    buildModels(): void;
+    rebuildModels(): void;
+    protected getModelType(): typeof RasterModel | typeof RasterRgbModel;
     protected getDefaultConfig(): {};
 }

package/es/tile/tileFactory/layers/{RasterDataLayer.js → rasterDataLayer.js}

@@ -1,12 +1,10 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
@@ -39,42 +37,32 @@ var RasterTiffLayer = /*#__PURE__*/function (_BaseLayer) {
 
   _createClass(RasterTiffLayer, [{
     key: "buildModels",
-    value: function () {
-      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var model;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                model = this.getModel();
-                this.layerModel = new model(this);
-                _context.next = 4;
-                return this.initLayerModels();
-
-              case 4:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
-
-      return buildModels;
-    }()
+    value: function buildModels() {
+      var _this2 = this;
+
+      var model = this.getModelType();
+      this.layerModel = new model(this);
+      this.layerModel.initModels(function (models) {
+        _this2.dispatchModelLoad(models);
+      });
+    }
   }, {
-    key: "getModel",
-    value: function getModel() {
-      var type = this.getModelType();
-      return type === 'rasterRgb' ? RasterRgbModel : RasterModel;
+    key: "rebuildModels",
+    value: function rebuildModels() {
+      var _this3 = this;
+
+      this.layerModel.buildModels(function (models) {
+        _this3.dispatchModelLoad(models);
+      });
     }
   }, {
     key: "getModelType",
     value: function getModelType() {
-      return this.layerSource.parser.type === 'rasterRgb' ? 'rasterRgb' : 'raster';
+      if (this.layerSource.parser.type === 'rasterRgb') {
+        return RasterRgbModel;
+      } else {
+        return RasterModel;
+      }
     }
   }, {
     key: "getDefaultConfig",

package/es/tile/tileFactory/layers/{TileDebugLayer.d.ts → tileTest.d.ts}

@@ -2,14 +2,14 @@ import BaseLayer from '../../../core/BaseLayer';
 import { IBaseLayerStyleOptions } from '../../../core/interface';
 export default class TileDebugLayer extends BaseLayer<IBaseLayerStyleOptions> {
     type: string;
-    zIndex: number;
     defaultSourceConfig: {
         data: never[];
         options: {
             parser: {
                 type: string;
+                cancelExtent: boolean;
             };
         };
     };
-    buildModels(): Promise<void>;
+    buildModels(): void;
 }

package/es/tile/tileFactory/layers/{TileDebugLayer.js → tileTest.js}

@@ -1,18 +1,17 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 import BaseLayer from "../../../core/BaseLayer";
+import TileModel from "../../models/tileModel";
 
 var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
   _inherits(TileDebugLayer, _BaseLayer);
@@ -32,13 +31,12 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
 
     _defineProperty(_assertThisInitialized(_this), "type", 'TileDebugLayer');
 
-    _defineProperty(_assertThisInitialized(_this), "zIndex", 10000);
-
     _defineProperty(_assertThisInitialized(_this), "defaultSourceConfig", {
       data: [],
       options: {
         parser: {
-          type: 'testTile'
+          type: 'testTile',
+          cancelExtent: true
         }
       }
     });
@@ -48,25 +46,14 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
 
   _createClass(TileDebugLayer, [{
     key: "buildModels",
-    value: function () {
-      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee);
-      }));
-
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
+    value: function buildModels() {
+      var _this2 = this;
 
-      return buildModels;
-    }()
+      this.layerModel = new TileModel(this);
+      this.layerModel.initModels(function (models) {
+        _this2.dispatchModelLoad(models);
+      });
+    }
   }]);
 
   return TileDebugLayer;