vlite3 1.4.27 → 1.4.30

package/types/GoogleMap.type.d.ts

@@ -0,0 +1,50 @@
+export interface GoogleMapCoordinate {
+    lat: number;
+    lng: number;
+}
+export interface GoogleMapMarker extends GoogleMapCoordinate {
+    id?: string | number;
+    title?: string;
+    label?: string;
+}
+export interface GoogleMapOptions {
+    disableDefaultUI?: boolean;
+    draggable?: boolean;
+    fullscreenControl?: boolean;
+    mapId?: string;
+    mapTypeControl?: boolean;
+    scrollwheel?: boolean;
+    streetViewControl?: boolean;
+    zoomControl?: boolean;
+    [key: string]: unknown;
+}
+export interface GoogleMapProps {
+    apiKey?: string;
+    center?: GoogleMapCoordinate | null;
+    markers?: GoogleMapMarker[];
+    zoom?: number;
+    height?: string | number;
+    width?: string | number;
+    options?: GoogleMapOptions;
+    ariaLabel?: string;
+    loadingText?: string;
+    errorText?: string;
+}
+export type GoogleMapErrorCode = 'invalid-api-key' | 'invalid-center' | 'invalid-markers' | 'loader-conflict' | 'load-failed' | 'ssr-unavailable';
+export interface GoogleMapError {
+    code: GoogleMapErrorCode;
+    message: string;
+    cause?: unknown;
+}
+export interface GoogleMapReadyEvent {
+    map: unknown;
+}
+export interface GoogleMapClickEvent {
+    coordinate: GoogleMapCoordinate | null;
+    nativeEvent: unknown;
+}
+export interface GoogleMapMarkerClickEvent {
+    marker: GoogleMapMarker;
+    index: number;
+    nativeEvent: unknown;
+}

package/types/config.type.d.ts

@@ -89,6 +89,9 @@ export interface VLiteConfig {
         datetime?: {
             format?: string;
         };
+        googleMap?: {
+            apiKey?: string;
+        };
         /**
          * Global Empty component configuration.
          * Sets the default variant used when no `variant` prop is passed locally.

package/types/index.d.ts

@@ -9,3 +9,4 @@ export * from './styles.ts';
 export * from './config.type';
 export * from './list.type';
 export * from './progressbar.ts';
+export * from './GoogleMap.type';

package/utils/GoogleMapLoader.d.ts

@@ -0,0 +1,41 @@
+import { GoogleMapError } from '../types/GoogleMap.type';
+interface GoogleMapsApi {
+    maps: {
+        Map: new (element: HTMLElement, options: Record<string, unknown>) => GoogleMapInstance;
+        Marker: new (options: Record<string, unknown>) => GoogleMapMarkerInstance;
+        event: {
+            clearInstanceListeners(instance: unknown): void;
+            trigger(instance: unknown, eventName: string): void;
+        };
+    };
+}
+export interface GoogleMapListener {
+    remove(): void;
+}
+export interface GoogleMapInstance {
+    addListener(eventName: string, handler: (event?: any) => void): GoogleMapListener;
+    getCenter(): {
+        lat(): number;
+        lng(): number;
+    } | undefined;
+    getZoom(): number | undefined;
+    setCenter(center: {
+        lat: number;
+        lng: number;
+    }): void;
+    setOptions(options: Record<string, unknown>): void;
+    setZoom(zoom: number): void;
+}
+export interface GoogleMapMarkerInstance {
+    addListener(eventName: string, handler: (event?: any) => void): GoogleMapListener;
+    setLabel(label: string | null): void;
+    setMap(map: GoogleMapInstance | null): void;
+    setPosition(position: {
+        lat: number;
+        lng: number;
+    }): void;
+    setTitle(title: string | null): void;
+}
+export declare function onGoogleMapsAuthFailure(handler: (error: GoogleMapError) => void): () => void;
+export declare function loadGoogleMaps(apiKey: string): Promise<GoogleMapsApi>;
+export {};

package/utils/GoogleMapLoader.js

@@ -0,0 +1,47 @@
+let t = null, d = null;
+const s = /* @__PURE__ */ new Set();
+let p = !1;
+function l(e, n, a) {
+  return { code: e, message: n, cause: a };
+}
+function f() {
+  if (p || typeof window > "u") return;
+  p = !0;
+  const e = window.gm_authFailure;
+  window.gm_authFailure = () => {
+    const n = l(
+      "invalid-api-key",
+      "Google Maps rejected the API key. Check its validity and Maps JavaScript API restrictions."
+    );
+    s.forEach((a) => a(n)), typeof e == "function" && e();
+  };
+}
+function g(e) {
+  return f(), s.add(e), () => s.delete(e);
+}
+function w(e) {
+  if (typeof window > "u" || typeof document > "u")
+    return Promise.reject(
+      l("ssr-unavailable", "Google Maps can only be initialized in a browser.")
+    );
+  const n = window.google;
+  return n?.maps?.Map ? Promise.resolve(n) : t ? d !== e ? Promise.reject(
+    l(
+      "loader-conflict",
+      "Google Maps is already loading with a different API key on this page."
+    )
+  ) : t : (d = e, f(), t = new Promise((a, u) => {
+    const r = `__vliteGoogleMapsReady_${Date.now()}`, o = document.createElement("script"), c = () => delete window[r];
+    window[r] = () => {
+      c();
+      const i = window.google;
+      i?.maps?.Map ? a(i) : u(l("load-failed", "Google Maps loaded without the Maps API."));
+    }, o.id = "vlite3-google-maps-script", o.async = !0, o.defer = !0, o.src = `https://maps.googleapis.com/maps/api/js?key=${encodeURIComponent(e)}&callback=${r}&loading=async`, o.onerror = (i) => {
+      c(), t = null, d = null, o.remove(), u(l("load-failed", "Google Maps could not be loaded.", i));
+    }, document.head.appendChild(o);
+  }), t);
+}
+export {
+  w as loadGoogleMaps,
+  g as onGoogleMapsAuthFailure
+};