xertica-ui 2.4.0 → 2.4.1

package/dist/google-maps-loader-BKcdgFbu.cjs

@@ -0,0 +1,312 @@
+"use strict";
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const GOOGLE_MAPS_LIBRARIES = [
+  "marker",
+  "places",
+  "geometry",
+  "drawing",
+  "maps"
+];
+const GOOGLE_MAPS_ID = "xertica-google-map-script";
+const __vite_import_meta_env__ = {};
+const GoogleMapsContext = React.createContext({
+  isLoaded: false,
+  loadError: void 0,
+  load: () => Promise.resolve()
+});
+function getInitialApiKey() {
+  if (typeof { url: typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("google-maps-loader-BKcdgFbu.cjs", document.baseURI).href } !== "undefined" && __vite_import_meta_env__ && "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo") {
+    return "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo";
+  }
+  if (typeof window === "undefined") return void 0;
+  const savedKey = window.localStorage?.getItem("xertica-googlemaps-api-key");
+  if (savedKey && savedKey.trim().length > 0) {
+    return savedKey;
+  }
+  return void 0;
+}
+function removeExistingScript() {
+  if (typeof window === "undefined") return;
+  if (window.__googleMapsCallback) {
+    delete window.__googleMapsCallback;
+  }
+  const existingScript = document.querySelector(`script[src*="maps.googleapis.com/maps/api/js"]`);
+  if (existingScript) {
+    existingScript.remove();
+  }
+  if (window.google?.maps) {
+    delete window.google.maps;
+  }
+  if (window.__XERTICA_GOOGLE_MAPS_LOADER__) {
+    window.__XERTICA_GOOGLE_MAPS_LOADER__.isLoaded = false;
+    window.__XERTICA_GOOGLE_MAPS_LOADER__.loadError = void 0;
+    window.__XERTICA_GOOGLE_MAPS_LOADER__.scriptElement = void 0;
+  }
+}
+function isGoogleMapsAlreadyLoaded() {
+  if (typeof window === "undefined") return false;
+  return window.google?.maps?.version !== void 0;
+}
+function isMarkerLibraryLoaded() {
+  if (typeof window === "undefined") return false;
+  return window.google?.maps?.marker?.AdvancedMarkerElement !== void 0;
+}
+function loadGoogleMapsScript(apiKey) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new Error("Window is undefined"));
+      return;
+    }
+    if (!apiKey || apiKey.length < 10) {
+      reject(
+        new Error(
+          "Invalid or missing Google Maps API key. Please configure your API key in Settings."
+        )
+      );
+      return;
+    }
+    if (isGoogleMapsAlreadyLoaded() && isMarkerLibraryLoaded()) {
+      const existingScript = document.querySelector(
+        `script[src*="maps.googleapis.com/maps/api/js"]`
+      );
+      if (existingScript && existingScript.src.includes(`key=${apiKey}`)) {
+        resolve();
+        return;
+      }
+    }
+    const existing = document.querySelector(
+      `script[src*="maps.googleapis.com/maps/api/js"]`
+    );
+    if (existing) {
+      if (!existing.src.includes(`key=${apiKey}`)) {
+        console.warn(
+          "[GoogleMapsLoader] API key changed, but Google Maps cannot be reloaded without a full page refresh because custom elements are already defined."
+        );
+        resolve();
+        return;
+      }
+      if (isGoogleMapsAlreadyLoaded() && isMarkerLibraryLoaded()) {
+        resolve();
+      } else {
+        existing.addEventListener("load", () => {
+          setTimeout(() => {
+            if (isMarkerLibraryLoaded()) {
+              resolve();
+            } else {
+              reject(new Error("Marker library failed to load"));
+            }
+          }, 100);
+        });
+        existing.addEventListener("error", () => reject(new Error("Failed to load Google Maps")));
+      }
+      return;
+    }
+    if (typeof customElements !== "undefined" && customElements.get("gmp-map")) {
+      console.warn(
+        "[GoogleMapsLoader] gmp-map is already defined in customElements. Skipping script injection."
+      );
+      resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    const params = new URLSearchParams({
+      key: apiKey,
+      // SEMPRE incluir a API key
+      callback: "__googleMapsCallback",
+      libraries: GOOGLE_MAPS_LIBRARIES.join(","),
+      v: "quarterly",
+      // Usar 'quarterly' para versão estável ao invés de 'weekly'
+      loading: "async"
+    });
+    script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+    script.async = true;
+    script.defer = true;
+    script.id = GOOGLE_MAPS_ID;
+    window.__googleMapsCallback = () => {
+      delete window.__googleMapsCallback;
+      setTimeout(() => {
+        if (isMarkerLibraryLoaded()) {
+          resolve();
+        } else {
+          reject(new Error("Marker library failed to load"));
+        }
+      }, 100);
+    };
+    script.addEventListener("error", () => {
+      delete window.__googleMapsCallback;
+      reject(
+        new Error(
+          "Failed to load Google Maps script. Please check your API key and ensure Maps JavaScript API is enabled."
+        )
+      );
+    });
+    document.head.appendChild(script);
+    const singleton = getOrCreateSingleton();
+    if (singleton) {
+      singleton.scriptElement = script;
+    }
+  });
+}
+function getOrCreateSingleton() {
+  if (typeof window === "undefined") return null;
+  if (!window.__XERTICA_GOOGLE_MAPS_LOADER__) {
+    const isPreloaded = isGoogleMapsAlreadyLoaded();
+    window.__XERTICA_GOOGLE_MAPS_LOADER__ = {
+      isLoaded: isPreloaded,
+      loadError: void 0,
+      listeners: /* @__PURE__ */ new Set(),
+      scriptElement: void 0
+    };
+  }
+  return window.__XERTICA_GOOGLE_MAPS_LOADER__;
+}
+function updateSingleton(state) {
+  const singleton = getOrCreateSingleton();
+  if (!singleton) return;
+  if (state.isLoaded !== void 0) singleton.isLoaded = state.isLoaded;
+  if (state.loadError !== void 0) singleton.loadError = state.loadError;
+  const newState = {
+    isLoaded: singleton.isLoaded,
+    loadError: singleton.loadError,
+    load: async (apiKey) => {
+      if (singleton.isLoaded) return;
+      try {
+        await loadGoogleMapsScript(apiKey);
+        updateSingleton({ isLoaded: true, loadError: void 0 });
+      } catch (error) {
+        updateSingleton({ isLoaded: false, loadError: error });
+        throw error;
+      }
+    }
+  };
+  singleton.listeners.forEach((listener) => listener(newState));
+}
+const SingletonLoaderWrapper = ({ children }) => {
+  const [state, setState] = React.useState(() => {
+    const singleton = getOrCreateSingleton();
+    const loadFn = async (apiKey) => {
+      if (singleton?.isLoaded) return;
+      try {
+        await loadGoogleMapsScript(apiKey);
+        updateSingleton({ isLoaded: true, loadError: void 0 });
+      } catch (error) {
+        updateSingleton({ isLoaded: false, loadError: error });
+        throw error;
+      }
+    };
+    if (!singleton) return { isLoaded: false, loadError: void 0, load: loadFn };
+    return {
+      isLoaded: singleton.isLoaded,
+      loadError: singleton.loadError,
+      load: loadFn
+    };
+  });
+  React.useEffect(() => {
+    const singleton = getOrCreateSingleton();
+    if (!singleton) return;
+    const listener = (newState) => {
+      setState(newState);
+    };
+    singleton.listeners.add(listener);
+    listener({
+      isLoaded: singleton.isLoaded,
+      loadError: singleton.loadError,
+      load: state.load
+    });
+    return () => {
+      singleton.listeners.delete(listener);
+    };
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsx(GoogleMapsContext.Provider, { value: state, children });
+};
+const LoaderInitializer = ({ apiKey }) => {
+  const hasInitializedRef = React.useRef(false);
+  React.useEffect(() => {
+    if (hasInitializedRef.current) {
+      return;
+    }
+    const singleton = getOrCreateSingleton();
+    if (!singleton) return;
+    if (isGoogleMapsAlreadyLoaded() && isMarkerLibraryLoaded()) {
+      updateSingleton({ isLoaded: true, loadError: void 0 });
+      hasInitializedRef.current = true;
+      return;
+    }
+    hasInitializedRef.current = true;
+    const keyToUse = apiKey || getInitialApiKey();
+    if (!keyToUse) {
+      updateSingleton({
+        isLoaded: false,
+        loadError: void 0
+        // Não definir erro quando não há API key
+      });
+      return;
+    }
+    loadGoogleMapsScript(keyToUse).then(() => {
+      updateSingleton({ isLoaded: true, loadError: void 0 });
+    }).catch((error) => {
+      updateSingleton({ isLoaded: false, loadError: error });
+    });
+  }, [apiKey]);
+  return null;
+};
+const GoogleMapsLoaderProvider = ({ children, apiKey }) => {
+  const [shouldInitialize] = React.useState(() => {
+    const singleton = getOrCreateSingleton();
+    if (!singleton) return false;
+    if (singleton.isLoaded || isGoogleMapsAlreadyLoaded() || isMarkerLibraryLoaded()) {
+      singleton.isLoaded = true;
+      return false;
+    }
+    return true;
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    shouldInitialize && /* @__PURE__ */ jsxRuntime.jsx(LoaderInitializer, { apiKey }),
+    /* @__PURE__ */ jsxRuntime.jsx(SingletonLoaderWrapper, { children })
+  ] });
+};
+const useGoogleMapsLoader = () => React.useContext(GoogleMapsContext);
+function reloadGoogleMaps(newApiKey) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new Error("Window is undefined"));
+      return;
+    }
+    if (!newApiKey || newApiKey.length < 10) {
+      reject(new Error("Invalid or missing Google Maps API key"));
+      return;
+    }
+    const existingScript = document.querySelector(
+      `script[src*="maps.googleapis.com/maps/api/js"]`
+    );
+    if (existingScript && existingScript.src.includes(`key=${newApiKey}`)) {
+      resolve();
+      return;
+    }
+    if (typeof customElements !== "undefined" && customElements.get("gmp-map")) {
+      console.warn(
+        "[GoogleMapsLoader] Cannot reload map API dynamically because custom elements (gmp-map) are already registered. A full page reload is required to apply the new API key."
+      );
+      resolve();
+      return;
+    }
+    removeExistingScript();
+    updateSingleton({ isLoaded: false, loadError: void 0 });
+    loadGoogleMapsScript(newApiKey).then(() => {
+      updateSingleton({ isLoaded: true, loadError: void 0 });
+      resolve();
+    }).catch((error) => {
+      updateSingleton({ isLoaded: false, loadError: error });
+      reject(error);
+    });
+  });
+}
+const GoogleMapsProvider = GoogleMapsLoaderProvider;
+exports.GOOGLE_MAPS_ID = GOOGLE_MAPS_ID;
+exports.GOOGLE_MAPS_LIBRARIES = GOOGLE_MAPS_LIBRARIES;
+exports.GoogleMapsLoaderProvider = GoogleMapsLoaderProvider;
+exports.GoogleMapsProvider = GoogleMapsProvider;
+exports.reloadGoogleMaps = reloadGoogleMaps;
+exports.useGoogleMapsLoader = useGoogleMapsLoader;

package/dist/{google-maps-loader-t2IlYBzw.js → google-maps-loader-CTYySAun.js}

@@ -2,6 +2,7 @@ import { jsxs, Fragment, jsx } from "react/jsx-runtime";
 import { createContext, useContext, useState, useRef, useEffect } from "react";
 const GOOGLE_MAPS_LIBRARIES = ["marker", "places", "geometry", "drawing", "maps"];
 const GOOGLE_MAPS_ID = "xertica-google-map-script";
+const __vite_import_meta_env__ = {};
 const GoogleMapsContext = createContext({
   isLoaded: false,
   loadError: void 0,
@@ -9,6 +10,9 @@ const GoogleMapsContext = createContext({
 });
 function getInitialApiKey() {
   var _a;
+  if (typeof import.meta !== "undefined" && __vite_import_meta_env__ && "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo") {
+    return "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo";
+  }
   if (typeof window === "undefined") return void 0;
   const savedKey = (_a = window.localStorage) == null ? void 0 : _a.getItem("xertica-googlemaps-api-key");
   if (savedKey && savedKey.trim().length > 0) {

package/dist/google-maps-loader-CumCNXeG.js

@@ -0,0 +1,312 @@
+import { jsxs, Fragment, jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useRef, useEffect } from "react";
+const GOOGLE_MAPS_LIBRARIES = [
+  "marker",
+  "places",
+  "geometry",
+  "drawing",
+  "maps"
+];
+const GOOGLE_MAPS_ID = "xertica-google-map-script";
+const __vite_import_meta_env__ = {};
+const GoogleMapsContext = createContext({
+  isLoaded: false,
+  loadError: void 0,
+  load: () => Promise.resolve()
+});
+function getInitialApiKey() {
+  if (typeof import.meta !== "undefined" && __vite_import_meta_env__ && "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo") {
+    return "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo";
+  }
+  if (typeof window === "undefined") return void 0;
+  const savedKey = window.localStorage?.getItem("xertica-googlemaps-api-key");
+  if (savedKey && savedKey.trim().length > 0) {
+    return savedKey;
+  }
+  return void 0;
+}
+function removeExistingScript() {
+  if (typeof window === "undefined") return;
+  if (window.__googleMapsCallback) {
+    delete window.__googleMapsCallback;
+  }
+  const existingScript = document.querySelector(`script[src*="maps.googleapis.com/maps/api/js"]`);
+  if (existingScript) {
+    existingScript.remove();
+  }
+  if (window.google?.maps) {
+    delete window.google.maps;
+  }
+  if (window.__XERTICA_GOOGLE_MAPS_LOADER__) {
+    window.__XERTICA_GOOGLE_MAPS_LOADER__.isLoaded = false;
+    window.__XERTICA_GOOGLE_MAPS_LOADER__.loadError = void 0;
+    window.__XERTICA_GOOGLE_MAPS_LOADER__.scriptElement = void 0;
+  }
+}
+function isGoogleMapsAlreadyLoaded() {
+  if (typeof window === "undefined") return false;
+  return window.google?.maps?.version !== void 0;
+}
+function isMarkerLibraryLoaded() {
+  if (typeof window === "undefined") return false;
+  return window.google?.maps?.marker?.AdvancedMarkerElement !== void 0;
+}
+function loadGoogleMapsScript(apiKey) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new Error("Window is undefined"));
+      return;
+    }
+    if (!apiKey || apiKey.length < 10) {
+      reject(
+        new Error(
+          "Invalid or missing Google Maps API key. Please configure your API key in Settings."
+        )
+      );
+      return;
+    }
+    if (isGoogleMapsAlreadyLoaded() && isMarkerLibraryLoaded()) {
+      const existingScript = document.querySelector(
+        `script[src*="maps.googleapis.com/maps/api/js"]`
+      );
+      if (existingScript && existingScript.src.includes(`key=${apiKey}`)) {
+        resolve();
+        return;
+      }
+    }
+    const existing = document.querySelector(
+      `script[src*="maps.googleapis.com/maps/api/js"]`
+    );
+    if (existing) {
+      if (!existing.src.includes(`key=${apiKey}`)) {
+        console.warn(
+          "[GoogleMapsLoader] API key changed, but Google Maps cannot be reloaded without a full page refresh because custom elements are already defined."
+        );
+        resolve();
+        return;
+      }
+      if (isGoogleMapsAlreadyLoaded() && isMarkerLibraryLoaded()) {
+        resolve();
+      } else {
+        existing.addEventListener("load", () => {
+          setTimeout(() => {
+            if (isMarkerLibraryLoaded()) {
+              resolve();
+            } else {
+              reject(new Error("Marker library failed to load"));
+            }
+          }, 100);
+        });
+        existing.addEventListener("error", () => reject(new Error("Failed to load Google Maps")));
+      }
+      return;
+    }
+    if (typeof customElements !== "undefined" && customElements.get("gmp-map")) {
+      console.warn(
+        "[GoogleMapsLoader] gmp-map is already defined in customElements. Skipping script injection."
+      );
+      resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    const params = new URLSearchParams({
+      key: apiKey,
+      // SEMPRE incluir a API key
+      callback: "__googleMapsCallback",
+      libraries: GOOGLE_MAPS_LIBRARIES.join(","),
+      v: "quarterly",
+      // Usar 'quarterly' para versão estável ao invés de 'weekly'
+      loading: "async"
+    });
+    script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+    script.async = true;
+    script.defer = true;
+    script.id = GOOGLE_MAPS_ID;
+    window.__googleMapsCallback = () => {
+      delete window.__googleMapsCallback;
+      setTimeout(() => {
+        if (isMarkerLibraryLoaded()) {
+          resolve();
+        } else {
+          reject(new Error("Marker library failed to load"));
+        }
+      }, 100);
+    };
+    script.addEventListener("error", () => {
+      delete window.__googleMapsCallback;
+      reject(
+        new Error(
+          "Failed to load Google Maps script. Please check your API key and ensure Maps JavaScript API is enabled."
+        )
+      );
+    });
+    document.head.appendChild(script);
+    const singleton = getOrCreateSingleton();
+    if (singleton) {
+      singleton.scriptElement = script;
+    }
+  });
+}
+function getOrCreateSingleton() {
+  if (typeof window === "undefined") return null;
+  if (!window.__XERTICA_GOOGLE_MAPS_LOADER__) {
+    const isPreloaded = isGoogleMapsAlreadyLoaded();
+    window.__XERTICA_GOOGLE_MAPS_LOADER__ = {
+      isLoaded: isPreloaded,
+      loadError: void 0,
+      listeners: /* @__PURE__ */ new Set(),
+      scriptElement: void 0
+    };
+  }
+  return window.__XERTICA_GOOGLE_MAPS_LOADER__;
+}
+function updateSingleton(state) {
+  const singleton = getOrCreateSingleton();
+  if (!singleton) return;
+  if (state.isLoaded !== void 0) singleton.isLoaded = state.isLoaded;
+  if (state.loadError !== void 0) singleton.loadError = state.loadError;
+  const newState = {
+    isLoaded: singleton.isLoaded,
+    loadError: singleton.loadError,
+    load: async (apiKey) => {
+      if (singleton.isLoaded) return;
+      try {
+        await loadGoogleMapsScript(apiKey);
+        updateSingleton({ isLoaded: true, loadError: void 0 });
+      } catch (error) {
+        updateSingleton({ isLoaded: false, loadError: error });
+        throw error;
+      }
+    }
+  };
+  singleton.listeners.forEach((listener) => listener(newState));
+}
+const SingletonLoaderWrapper = ({ children }) => {
+  const [state, setState] = useState(() => {
+    const singleton = getOrCreateSingleton();
+    const loadFn = async (apiKey) => {
+      if (singleton?.isLoaded) return;
+      try {
+        await loadGoogleMapsScript(apiKey);
+        updateSingleton({ isLoaded: true, loadError: void 0 });
+      } catch (error) {
+        updateSingleton({ isLoaded: false, loadError: error });
+        throw error;
+      }
+    };
+    if (!singleton) return { isLoaded: false, loadError: void 0, load: loadFn };
+    return {
+      isLoaded: singleton.isLoaded,
+      loadError: singleton.loadError,
+      load: loadFn
+    };
+  });
+  useEffect(() => {
+    const singleton = getOrCreateSingleton();
+    if (!singleton) return;
+    const listener = (newState) => {
+      setState(newState);
+    };
+    singleton.listeners.add(listener);
+    listener({
+      isLoaded: singleton.isLoaded,
+      loadError: singleton.loadError,
+      load: state.load
+    });
+    return () => {
+      singleton.listeners.delete(listener);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(GoogleMapsContext.Provider, { value: state, children });
+};
+const LoaderInitializer = ({ apiKey }) => {
+  const hasInitializedRef = useRef(false);
+  useEffect(() => {
+    if (hasInitializedRef.current) {
+      return;
+    }
+    const singleton = getOrCreateSingleton();
+    if (!singleton) return;
+    if (isGoogleMapsAlreadyLoaded() && isMarkerLibraryLoaded()) {
+      updateSingleton({ isLoaded: true, loadError: void 0 });
+      hasInitializedRef.current = true;
+      return;
+    }
+    hasInitializedRef.current = true;
+    const keyToUse = apiKey || getInitialApiKey();
+    if (!keyToUse) {
+      updateSingleton({
+        isLoaded: false,
+        loadError: void 0
+        // Não definir erro quando não há API key
+      });
+      return;
+    }
+    loadGoogleMapsScript(keyToUse).then(() => {
+      updateSingleton({ isLoaded: true, loadError: void 0 });
+    }).catch((error) => {
+      updateSingleton({ isLoaded: false, loadError: error });
+    });
+  }, [apiKey]);
+  return null;
+};
+const GoogleMapsLoaderProvider = ({ children, apiKey }) => {
+  const [shouldInitialize] = useState(() => {
+    const singleton = getOrCreateSingleton();
+    if (!singleton) return false;
+    if (singleton.isLoaded || isGoogleMapsAlreadyLoaded() || isMarkerLibraryLoaded()) {
+      singleton.isLoaded = true;
+      return false;
+    }
+    return true;
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    shouldInitialize && /* @__PURE__ */ jsx(LoaderInitializer, { apiKey }),
+    /* @__PURE__ */ jsx(SingletonLoaderWrapper, { children })
+  ] });
+};
+const useGoogleMapsLoader = () => useContext(GoogleMapsContext);
+function reloadGoogleMaps(newApiKey) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new Error("Window is undefined"));
+      return;
+    }
+    if (!newApiKey || newApiKey.length < 10) {
+      reject(new Error("Invalid or missing Google Maps API key"));
+      return;
+    }
+    const existingScript = document.querySelector(
+      `script[src*="maps.googleapis.com/maps/api/js"]`
+    );
+    if (existingScript && existingScript.src.includes(`key=${newApiKey}`)) {
+      resolve();
+      return;
+    }
+    if (typeof customElements !== "undefined" && customElements.get("gmp-map")) {
+      console.warn(
+        "[GoogleMapsLoader] Cannot reload map API dynamically because custom elements (gmp-map) are already registered. A full page reload is required to apply the new API key."
+      );
+      resolve();
+      return;
+    }
+    removeExistingScript();
+    updateSingleton({ isLoaded: false, loadError: void 0 });
+    loadGoogleMapsScript(newApiKey).then(() => {
+      updateSingleton({ isLoaded: true, loadError: void 0 });
+      resolve();
+    }).catch((error) => {
+      updateSingleton({ isLoaded: false, loadError: error });
+      reject(error);
+    });
+  });
+}
+const GoogleMapsProvider = GoogleMapsLoaderProvider;
+export {
+  GOOGLE_MAPS_ID as G,
+  GOOGLE_MAPS_LIBRARIES as a,
+  GoogleMapsLoaderProvider as b,
+  GoogleMapsProvider as c,
+  reloadGoogleMaps as r,
+  useGoogleMapsLoader as u
+};

package/dist/{google-maps-loader-BqsYL48U.cjs → google-maps-loader-Y-QkD-Li.cjs}

@@ -1,8 +1,10 @@
 "use strict";
 const jsxRuntime = require("react/jsx-runtime");
 const React = require("react");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 const GOOGLE_MAPS_LIBRARIES = ["marker", "places", "geometry", "drawing", "maps"];
 const GOOGLE_MAPS_ID = "xertica-google-map-script";
+const __vite_import_meta_env__ = {};
 const GoogleMapsContext = React.createContext({
   isLoaded: false,
   loadError: void 0,
@@ -10,6 +12,9 @@ const GoogleMapsContext = React.createContext({
 });
 function getInitialApiKey() {
   var _a;
+  if (typeof { url: typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("google-maps-loader-Y-QkD-Li.cjs", document.baseURI).href } !== "undefined" && __vite_import_meta_env__ && "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo") {
+    return "AIzaSyCj19NndSgZOb8057q24UbJtSsfVJiyVdo";
+  }
   if (typeof window === "undefined") return void 0;
   const savedKey = (_a = window.localStorage) == null ? void 0 : _a.getItem("xertica-googlemaps-api-key");
   if (savedKey && savedKey.trim().length > 0) {