https://asesoriasempresa.es/wp-content/themes/adforest/assests/leaflet/leaflet-fullscreen.js?ver=4156

1/*
2 * leaflet.fullscreen
3 * (c) Bruno B.; MIT License
4 * Uses fragments from the package 'screenfull'
5 */
6(function (root, factory) {
7  if (typeof define === "function" && define.amd) {
8    // define an AMD module that requires 'leaflet'
9    // and resolve to an object containing leaflet
10    define("leafletFullScreen", ["leaflet"], factory);
11  } else if (typeof module === "object" && module.exports) {
12    // define a CommonJS module that requires 'leaflet'
13    module.exports = factory(require("leaflet"));
14  } else {
15    // Assume 'leaflet' are loaded into global variable already
16    factory(root.L);
17  }
18})(typeof self !== "undefined" ? self : this, (leaflet) => {
19  "use strict";
20
21  if (typeof document === "undefined") {
22    console.warn(
23      '"window.document" is undefined; leaflet.fullscreen requires this object to access the DOM'
24    );
25    return false;
26  }
27
28  const nativeAPI = (() => {
29    const methodMap = [
30      // Standard
31      [
32        "requestFullscreen",
33        "exitFullscreen",
34        "fullscreenElement",
35        "fullscreenEnabled",
36        "fullscreenchange",
37        "fullscreenerror",
38      ],
39      // New WebKit
40      [
41        "webkitRequestFullscreen",
42        "webkitExitFullscreen",
43        "webkitFullscreenElement",
44        "webkitFullscreenEnabled",
45        "webkitfullscreenchange",
46        "webkitfullscreenerror",
47      ],
48    ];
49
50    const baseList = methodMap[0];
51    const ret = {};
52
53    for (const methodList of methodMap) {
54      if (methodList[1] in document) {
55        for (let i = 0; i < methodList.length; i++) {
56          ret[baseList[i]] = methodList[i];
57        }
58        return ret;
59      }
60    }
61
62    return false;
63  })();

64
65  const eventNameMap = {
66    change: nativeAPI.fullscreenchange,
67    error: nativeAPI.fullscreenerror,
68  };
69
70  const fullscreenAPI = {
71    request(element, options) {
72      return new Promise((resolve, reject) => {
73        const onFullScreenEntered = function () {
74          this.off("change", onFullScreenEntered);
75          resolve();
76        }.bind(this);
77
78        this.on("change", onFullScreenEntered);
79        element = element || document.documentElement;
80        const returnPromise = element[nativeAPI.requestFullscreen](options);
81        if (returnPromise instanceof Promise) {
82          returnPromise.then(onFullScreenEntered).catch(reject);
83        }
84      });
85    },
86    exit() {
87      return new Promise((resolve, reject) => {
88        if (!this.isFullscreen) {
89          resolve();
90          return;
91        }
92
93        const onFullScreenExit = function () {
94          this.off("change", onFullScreenExit);
95          resolve();
96        }.bind(this);
97
98        this.on("change", onFullScreenExit);
99        const returnPromise = document[nativeAPI.exitFullscreen]();
100        if (returnPromise instanceof Promise) {
101          returnPromise.then(onFullScreenExit).catch(reject);
102        }
103      });
104    },
105    on(event, callback) {
106      const eventName = eventNameMap[event];
107      if (eventName) {
108        document.addEventListener(eventName, callback, false);
109      }
110    },
111    off(event, callback) {
112      const eventName = eventNameMap[event];
113      if (eventName) {
114        document.removeEventListener(eventName, callback, false);
115      }
116    },
117    nativeAPI: nativeAPI,
118  };
119
120  Object.defineProperties(fullscreenAPI, {
121    isFullscreen: {
122      get() {
123        return Boolean(document[nativeAPI.fullscreenElement]);
124      },
125    },
126    isEnabled: {
127      enumerable: true,
128      get() {
129        // Coerce to boolean in case of old WebKit
130        return Boolean(document[nativeAPI.fullscreenEnabled]);
131      },
132    },
133  });
134
135  leaflet.Control.FullScreen = leaflet.Control.extend({
136    options: {
137      position: "topleft",
138      title: "Full Screen",
139      titleCancel: "Exit Full Screen",

140      forceSeparateButton: false,
141      forcePseudoFullscreen: false,
142      fullscreenElement: false,
143    },
144
145    _screenfull: fullscreenAPI,
146
147    onAdd(map) {
148      let className = "leaflet-control-zoom-fullscreen";
149      let container;
150      let content = "";
151
152      if (map.zoomControl && !this.options.forceSeparateButton) {
153        container = map.zoomControl._container;
154      } else {
155        container = leaflet.DomUtil.create("div", "leaflet-bar");
156      }
157
158      if (this.options.content) {
159        content = this.options.content;
160      } else {
161        className += " fullscreen-icon";
162      }
163
164      this._createButton(
165        this.options.title,
166        className,
167        content,
168        container,
169        this.toggleFullScreen,
170        this
171      );
172      this._map.fullscreenControl = this;
173
174      this._map.on("enterFullscreen exitFullscreen", this._toggleState, this);
175
176      return container;
177    },
178
179    onRemove() {
180      leaflet.DomEvent.off(this.link, "click", leaflet.DomEvent.stop).off(
181        this.link,
182        "click",
183        this.toggleFullScreen,
184        this
185      );
186
187      if (this._screenfull.isEnabled) {
188        leaflet.DomEvent.off(
189          this._container,
190          this._screenfull.nativeAPI.fullscreenchange,
191          leaflet.DomEvent.stop
192        ).off(
193          this._container,
194          this._screenfull.nativeAPI.fullscreenchange,
195          this._handleFullscreenChange,
196          this
197        );
198
199        leaflet.DomEvent.off(
200          document,
201          this._screenfull.nativeAPI.fullscreenchange,
202          leaflet.DomEvent.stop
203        ).off(
204          document,
205          this._screenfull.nativeAPI.fullscreenchange,
206          this._handleFullscreenChange,
207          this
208        );
209      }
210    },
211
212    _createButton(title, className, content, container, fn, context) {
213      this.link = leaflet.DomUtil.create("a", className, container);
214      this.link.href = "#";
215      this.link.title = title;
216      this.link.innerHTML = content;
217
218      this.link.setAttribute("role", "button");
219      this.link.setAttribute("aria-label", title);
220
221      L.DomEvent.disableClickPropagation(container);
222
223      leaflet.DomEvent.on(this.link, "click", leaflet.DomEvent.stop).on(
224        this.link,
225        "click",
226        fn,
227        context
228      );
229
230      if (this._screenfull.isEnabled) {
231        leaflet.DomEvent.on(
232          container,
233          this._screenfull.nativeAPI.fullscreenchange,
234          leaflet.DomEvent.stop
235        ).on(
236          container,
237          this._screenfull.nativeAPI.fullscreenchange,
238          this._handleFullscreenChange,
239          context
240        );
241
242        leaflet.DomEvent.on(
243          document,
244          this._screenfull.nativeAPI.fullscreenchange,
245          leaflet.DomEvent.stop
246        ).on(
247          document,
248          this._screenfull.nativeAPI.fullscreenchange,
249          this._handleFullscreenChange,
250          context
251        );
252      }
253
254      return this.link;
255    },
256
257    toggleFullScreen() {
258      const map = this._map;
259      map._exitFired = false;
260      if (map._isFullscreen) {
261        if (this._screenfull.isEnabled && !this.options.forcePseudoFullscreen) {
262          this._screenfull.exit();
263        } else {
264          leaflet.DomUtil.removeClass(
265            this.options.fullscreenElement
266              ? this.options.fullscreenElement
267              : map._container,
268            "leaflet-pseudo-fullscreen"
269          );
270          map.invalidateSize();
271        }
272        map.fire("exitFullscreen");
273        map._exitFired = true;
274        map._isFullscreen = false;
275      } else {
276        if (this._screenfull.isEnabled && !this.options.forcePseudoFullscreen) {
277          this._screenfull.request(
278            this.options.fullscreenElement
279              ? this.options.fullscreenElement
280              : map._container
281          );
282        } else {
283          leaflet.DomUtil.addClass(
284            this.options.fullscreenElement
285              ? this.options.fullscreenElement
286              : map._container,
287            "leaflet-pseudo-fullscreen"
288          );
289          map.invalidateSize();
290        }
291        map.fire("enterFullscreen");
292        map._isFullscreen = true;
293      }
294    },
295
296    _toggleState() {
297      this.link.title = this._map._isFullscreen
298        ? this.options.title
299        : this.options.titleCancel;
300      this._map._isFullscreen
301        ? L.DomUtil.removeClass(this.link, "leaflet-fullscreen-on")
302        : L.DomUtil.addClass(this.link, "leaflet-fullscreen-on");
303    },
304
305    _handleFullscreenChange(ev) {
306      const map = this._map;
307      if (
308        ev.target === map.getContainer() &&
309        !this._screenfull.isFullscreen &&
310        !map._exitFired
311      ) {
312        map.invalidateSize();
313        map.fire("exitFullscreen");
314        map._exitFired = true;
315        map._isFullscreen = false;
316      }
317    },
318  });
319
320  leaflet.Map.include({
321    toggleFullscreen() {
322      this.fullscreenControl.toggleFullScreen();
323    },
324  });
325
326  leaflet.Map.addInitHook(function () {
327    if (this.options.fullscreenControl) {
328      this.addControl(
329        leaflet.control.fullscreen(this.options.fullscreenControlOptions)
330      );
331    }
332  });
333
334  leaflet.control.fullscreen = function (options) {
335    return new leaflet.Control.FullScreen(options);
336  };
337
338  return { leaflet };
339});