planning

node_modules/ol/Map.js

@@ -0,0 +1,94 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/**
+ * @module ol/Map
+ */
+import CompositeMapRenderer from './renderer/Composite.js';
+import PluggableMap from './PluggableMap.js';
+import { assign } from './obj.js';
+import { defaults as defaultControls } from './control.js';
+import { defaults as defaultInteractions } from './interaction.js';
+/**
+ * @classdesc
+ * The map is the core component of OpenLayers. For a map to render, a view,
+ * one or more layers, and a target container are needed:
+ *
+ *     import Map from 'ol/Map';
+ *     import View from 'ol/View';
+ *     import TileLayer from 'ol/layer/Tile';
+ *     import OSM from 'ol/source/OSM';
+ *
+ *     var map = new Map({
+ *       view: new View({
+ *         center: [0, 0],
+ *         zoom: 1
+ *       }),
+ *       layers: [
+ *         new TileLayer({
+ *           source: new OSM()
+ *         })
+ *       ],
+ *       target: 'map'
+ *     });
+ *
+ * The above snippet creates a map using a {@link module:ol/layer/Tile~TileLayer} to
+ * display {@link module:ol/source/OSM~OSM} OSM data and render it to a DOM
+ * element with the id `map`.
+ *
+ * The constructor places a viewport container (with CSS class name
+ * `ol-viewport`) in the target element (see `getViewport()`), and then two
+ * further elements within the viewport: one with CSS class name
+ * `ol-overlaycontainer-stopevent` for controls and some overlays, and one with
+ * CSS class name `ol-overlaycontainer` for other overlays (see the `stopEvent`
+ * option of {@link module:ol/Overlay~Overlay} for the difference). The map
+ * itself is placed in a further element within the viewport.
+ *
+ * Layers are stored as a {@link module:ol/Collection~Collection} in
+ * layerGroups. A top-level group is provided by the library. This is what is
+ * accessed by `getLayerGroup` and `setLayerGroup`. Layers entered in the
+ * options are added to this group, and `addLayer` and `removeLayer` change the
+ * layer collection in the group. `getLayers` is a convenience function for
+ * `getLayerGroup().getLayers()`. Note that {@link module:ol/layer/Group~LayerGroup}
+ * is a subclass of {@link module:ol/layer/Base~BaseLayer}, so layers entered in the
+ * options or added with `addLayer` can be groups, which can contain further
+ * groups, and so on.
+ *
+ * @api
+ */
+var Map = /** @class */ (function (_super) {
+    __extends(Map, _super);
+    /**
+     * @param {import("./PluggableMap.js").MapOptions} options Map options.
+     */
+    function Map(options) {
+        options = assign({}, options);
+        if (!options.controls) {
+            options.controls = defaultControls();
+        }
+        if (!options.interactions) {
+            options.interactions = defaultInteractions({
+                onFocusOnly: true,
+            });
+        }
+        return _super.call(this, options) || this;
+    }
+    Map.prototype.createRenderer = function () {
+        return new CompositeMapRenderer(this);
+    };
+    return Map;
+}(PluggableMap));
+export default Map;
+//# sourceMappingURL=Map.js.map