@nuxt/scripts 1.0.0-beta.7 → 1.0.0-rc.10

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsOverlayView.vue

@@ -0,0 +1,263 @@
+<script>
+
+</script>
+
+<script setup>
+import { computed, inject, shallowRef, useTemplateRef, watch } from "vue";
+import { MARKER_CLUSTERER_INJECTION_KEY } from "./types";
+import { defineDeprecatedAlias, MARKER_INJECTION_KEY, normalizeLatLng, useGoogleMapsResource } from "./useGoogleMapsResource";
+defineOptions({
+  inheritAttrs: false
+});
+const {
+  position,
+  defaultOpen = true,
+  anchor = "bottom-center",
+  offset,
+  pane = "floatPane",
+  zIndex,
+  blockMapInteraction = true,
+  panOnOpen = true,
+  hideWhenClustered = true
+} = defineProps({
+  position: { type: null, required: false },
+  defaultOpen: { type: Boolean, required: false },
+  anchor: { type: String, required: false },
+  offset: { type: Object, required: false },
+  pane: { type: String, required: false },
+  zIndex: { type: Number, required: false },
+  blockMapInteraction: { type: Boolean, required: false },
+  panOnOpen: { type: [Boolean, Number], required: false },
+  hideWhenClustered: { type: Boolean, required: false }
+});
+defineSlots();
+const open = defineModel("open", { type: Boolean, ...{ default: void 0 } });
+if (open.value === void 0)
+  open.value = defaultOpen ?? true;
+const markerContext = inject(MARKER_INJECTION_KEY, void 0);
+const markerClustererContext = inject(MARKER_CLUSTERER_INJECTION_KEY, void 0);
+function getResolvedPosition() {
+  if (position)
+    return normalizeLatLng(position);
+  const markerPosition = markerContext?.advancedMarkerElement.value?.position;
+  if (markerPosition)
+    return normalizeLatLng(markerPosition);
+  return void 0;
+}
+const ANCHOR_TRANSFORMS = {
+  "center": "translate(-50%, -50%)",
+  "top-left": "translate(0, 0)",
+  "top-center": "translate(-50%, 0)",
+  "top-right": "translate(-100%, 0)",
+  "bottom-left": "translate(0, -100%)",
+  "bottom-center": "translate(-50%, -100%)",
+  "bottom-right": "translate(-100%, -100%)",
+  "left-center": "translate(0, -50%)",
+  "right-center": "translate(-100%, -50%)"
+};
+const overlayAnchor = useTemplateRef("overlay-anchor");
+const overlayPosition = shallowRef(void 0);
+const dataState = computed(
+  () => open.value !== false && overlayPosition.value !== void 0 ? "open" : "closed"
+);
+const overlayStyle = computed(() => {
+  const visible = open.value !== false && overlayPosition.value !== void 0;
+  if (!visible) {
+    return {
+      position: "absolute",
+      visibility: "hidden",
+      pointerEvents: "none"
+    };
+  }
+  const { x, y } = overlayPosition.value;
+  return {
+    position: "absolute",
+    left: `${x + (offset?.x ?? 0)}px`,
+    top: `${y + (offset?.y ?? 0)}px`,
+    transform: ANCHOR_TRANSFORMS[anchor],
+    zIndex: zIndex !== void 0 ? String(zIndex) : void 0,
+    visibility: "visible",
+    pointerEvents: "auto"
+  };
+});
+const listeners = [];
+function panMapToFitOverlay(el, map, padding) {
+  const child = el.firstElementChild;
+  if (!child)
+    return;
+  const overlayRect = child.getBoundingClientRect();
+  const mapRect = map.getDiv().getBoundingClientRect();
+  let panX = 0;
+  let panY = 0;
+  if (overlayRect.top - padding < mapRect.top)
+    panY = overlayRect.top - mapRect.top - padding;
+  if (overlayRect.bottom + padding > mapRect.bottom)
+    panY = overlayRect.bottom - mapRect.bottom + padding;
+  if (overlayRect.left - padding < mapRect.left)
+    panX = overlayRect.left - mapRect.left - padding;
+  else if (overlayRect.right + padding > mapRect.right)
+    panX = overlayRect.right - mapRect.right + padding;
+  if (panX !== 0 || panY !== 0)
+    map.panBy(panX, panY);
+}
+function makeOverlayClass(mapsApi, map) {
+  return class CustomOverlay extends mapsApi.OverlayView {
+    onAdd() {
+      const panes = this.getPanes();
+      const el = overlayAnchor.value;
+      if (panes && el) {
+        panes[pane].appendChild(el);
+        if (blockMapInteraction)
+          mapsApi.OverlayView.preventMapHitsAndGesturesFrom(el);
+      }
+      if (panOnOpen && open.value !== false) {
+        const padding = typeof panOnOpen === "number" ? panOnOpen : 40;
+        requestAnimationFrame(() => {
+          if (open.value !== false && overlayAnchor.value && overlayPosition.value)
+            panMapToFitOverlay(overlayAnchor.value, map, padding);
+        });
+      }
+    }
+    draw() {
+      if (open.value === false) {
+        overlayPosition.value = void 0;
+        return;
+      }
+      const resolvedPosition = getResolvedPosition();
+      if (!resolvedPosition) {
+        overlayPosition.value = void 0;
+        return;
+      }
+      const projection = this.getProjection();
+      if (!projection) {
+        overlayPosition.value = void 0;
+        return;
+      }
+      const pos = projection.fromLatLngToDivPixel(
+        new mapsApi.LatLng(resolvedPosition.lat, resolvedPosition.lng)
+      );
+      if (!pos) {
+        overlayPosition.value = void 0;
+        return;
+      }
+      overlayPosition.value = { x: pos.x, y: pos.y };
+    }
+    onRemove() {
+      const el = overlayAnchor.value;
+      el?.parentNode?.removeChild(el);
+    }
+  };
+}
+const overlay = useGoogleMapsResource({
+  // ready condition accesses .value on ShallowRefs — tracked by whenever() in useGoogleMapsResource
+  ready: () => !!overlayAnchor.value && !!(position || markerContext?.advancedMarkerElement.value),
+  create({ mapsApi, map }) {
+    const CustomOverlay = makeOverlayClass(mapsApi, map);
+    const ov = new CustomOverlay();
+    ov.setMap(map);
+    if (markerContext?.advancedMarkerElement.value) {
+      const ame = markerContext.advancedMarkerElement.value;
+      listeners.push(
+        ame.addListener("drag", () => ov.draw()),
+        ame.addListener("dragend", () => ov.draw())
+      );
+    }
+    return ov;
+  },
+  cleanup(ov) {
+    listeners.forEach((l) => l.remove());
+    listeners.length = 0;
+    ov.setMap(null);
+  }
+});
+if (markerContext) {
+  watch(
+    () => {
+      const markerPosition = markerContext.advancedMarkerElement.value?.position;
+      return markerPosition ? normalizeLatLng(markerPosition) : void 0;
+    },
+    () => {
+      overlay.value?.draw();
+    }
+  );
+}
+watch(
+  () => {
+    const p = position ? normalizeLatLng(position) : void 0;
+    return [p?.lat, p?.lng, offset?.x, offset?.y, zIndex, anchor];
+  },
+  () => {
+    overlay.value?.draw();
+  }
+);
+watch(() => open.value, () => {
+  if (!overlay.value)
+    return;
+  overlay.value.draw();
+});
+watch([() => pane, () => blockMapInteraction], () => {
+  if (overlay.value) {
+    const map = overlay.value.getMap();
+    overlay.value.setMap(null);
+    if (map)
+      overlay.value.setMap(map);
+  }
+});
+if (markerClustererContext && markerContext) {
+  watch(
+    () => markerClustererContext.clusteringVersion.value,
+    () => {
+      if (!hideWhenClustered || open.value === false)
+        return;
+      const clusterer = markerClustererContext.markerClusterer.value;
+      if (!clusterer?.clusters)
+        return;
+      const parentMarker = markerContext.advancedMarkerElement.value;
+      if (!parentMarker)
+        return;
+      const isClustered = clusterer.clusters.some(
+        (cluster) => cluster.count > 1 && cluster.markers?.includes(parentMarker)
+      );
+      if (isClustered)
+        open.value = false;
+    }
+  );
+}
+const exposed = {
+  overlayView: overlay,
+  // Plain alias for production. In dev, replaced below with a getter that
+  // emits a one-shot deprecation warning. Both forms return the same
+  // shallow ref as `overlayView`.
+  overlay,
+  dataState
+};
+if (import.meta.dev) {
+  defineDeprecatedAlias(
+    exposed,
+    "overlay",
+    "overlayView",
+    '[nuxt-scripts] <ScriptGoogleMapsOverlayView> expose key "overlay" is deprecated; use "overlayView" instead. See https://scripts.nuxt.com/docs/migration-guide/v0-to-v1'
+  );
+}
+defineExpose(exposed);
+</script>
+
+<template>
+  <div style="display: none;">
+    <!--
+      Two-element structure:
+        - `overlay-anchor` is moved into a Google Maps pane on `onAdd()`. Its
+          inline style is reactively bound to `overlayStyle`, so position
+          updates from `draw()` flow through Vue's patcher even after the node
+          has been reparented out of the component tree.
+        - `overlay-content` carries `data-state`, attribute-based animations,
+          and forwards parent attrs (e.g. `class`) so consumers can target it
+          directly with `[data-state]` selectors.
+    -->
+    <div ref="overlay-anchor" :style="overlayStyle">
+      <div :data-state="dataState" v-bind="$attrs">
+        <slot />
+      </div>
+    </div>
+  </div>
+</template>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsOverlayView.vue.d.ts

@@ -0,0 +1,98 @@
+import type { ShallowRef } from 'vue';
+export type ScriptGoogleMapsOverlayAnchor = 'center' | 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right' | 'left-center' | 'right-center';
+export type ScriptGoogleMapsOverlayPane = 'mapPane' | 'overlayLayer' | 'markerLayer' | 'overlayMouseTarget' | 'floatPane';
+export interface ScriptGoogleMapsOverlayViewProps {
+    /**
+     * Geographic position for the overlay. Falls back to parent marker position if omitted.
+     *
+     * Accepts either a plain `LatLngLiteral` (`{ lat, lng }`) or a
+     * `google.maps.LatLng` instance.
+     * @see https://developers.google.com/maps/documentation/javascript/reference/overlay-view#OverlayView
+     */
+    position?: google.maps.LatLng | google.maps.LatLngLiteral;
+    /**
+     * Initial open state for the uncontrolled mode (when `v-model:open` is not
+     * bound). When omitted, the overlay opens on mount, matching v0 behaviour.
+     *
+     * Has no effect when `v-model:open` is used; pass an initial value to the
+     * bound ref instead.
+     * @default true
+     */
+    defaultOpen?: boolean;
+    /**
+     * Anchor point of the overlay relative to its position.
+     * @default 'bottom-center'
+     */
+    anchor?: ScriptGoogleMapsOverlayAnchor;
+    /**
+     * Pixel offset from the anchor position.
+     */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * The map pane on which to render the overlay.
+     * @default 'floatPane'
+     * @see https://developers.google.com/maps/documentation/javascript/reference/overlay-view#MapPanes
+     */
+    pane?: ScriptGoogleMapsOverlayPane;
+    /**
+     * CSS z-index for the overlay element.
+     */
+    zIndex?: number;
+    /**
+     * Whether to block map click and gesture events from passing through the overlay.
+     * @default true
+     */
+    blockMapInteraction?: boolean;
+    /**
+     * Pan the map so the overlay is fully visible when opened, similar to InfoWindow behavior.
+     * Set to `true` for default 40px padding, or a number for custom padding.
+     * @default true
+     */
+    panOnOpen?: boolean | number;
+    /**
+     * Automatically hide the overlay when its parent marker joins a cluster (on zoom out).
+     * Only applies when nested inside a ScriptGoogleMapsMarkerClusterer.
+     * @default true
+     */
+    hideWhenClustered?: boolean;
+}
+export interface ScriptGoogleMapsOverlayViewEmits {
+    /** Event handler called when the open state of the overlay view changes. */
+    'update:open': [value: boolean];
+}
+export interface ScriptGoogleMapsOverlayViewSlots {
+    default?: () => any;
+}
+export interface ScriptGoogleMapsOverlayViewExpose {
+    /** The underlying `OverlayView` instance. */
+    overlayView: ShallowRef<google.maps.OverlayView | undefined>;
+    /**
+     * The underlying `OverlayView` instance.
+     *
+     * @deprecated Use `overlayView` instead. The `overlay` alias will be
+     * removed in a future major version.
+     * @see https://scripts.nuxt.com/docs/migration-guide/v0-to-v1
+     */
+    overlay: ShallowRef<google.maps.OverlayView | undefined>;
+    /** The current data-state of the overlay, either 'open' or 'closed'. */
+    dataState: Readonly<ShallowRef<'open' | 'closed'>>;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<ScriptGoogleMapsOverlayViewProps & {
+    open?: boolean;
+}, ScriptGoogleMapsOverlayViewExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<ScriptGoogleMapsOverlayViewProps & {
+    open?: boolean;
+}> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ScriptGoogleMapsOverlayViewSlots>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPinElement.d.vue.ts

@@ -1,6 +1,13 @@
-type __VLS_Props = {
-    options?: Omit<google.maps.marker.PinElementOptions, 'map'>;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPinElement.vue

@@ -1,43 +1,11 @@
-<template>
-
-</template>
-
 <script setup>
-import { inject, onUnmounted, shallowRef } from "vue";
-import { whenever } from "@vueuse/core";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
-import { ADVANCED_MARKER_ELEMENT_INJECTION_KEY } from "./ScriptGoogleMapsAdvancedMarkerElement.vue";
-const props = defineProps({
-  options: { type: Object, required: false }
-});
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
-const advancedMarkerElementContext = inject(ADVANCED_MARKER_ELEMENT_INJECTION_KEY, void 0);
-const pinElement = shallowRef(void 0);
-whenever(
-  () => mapContext?.map.value && mapContext.mapsApi.value && advancedMarkerElementContext?.advancedMarkerElement.value,
-  async () => {
-    await mapContext.mapsApi.value.importLibrary("marker");
-    pinElement.value = new mapContext.mapsApi.value.marker.PinElement(props.options);
-    if (advancedMarkerElementContext?.advancedMarkerElement.value) {
-      advancedMarkerElementContext.advancedMarkerElement.value.content = pinElement.value.element;
-    }
-    whenever(() => props.options, (options) => {
-      if (pinElement.value && options) {
-        Object.assign(pinElement.value, options);
-      }
-    }, {
-      deep: true
-    });
-  },
-  {
-    immediate: true,
-    once: true
-  }
-);
-onUnmounted(() => {
-  if (advancedMarkerElementContext?.advancedMarkerElement.value && pinElement.value) {
-    advancedMarkerElementContext.advancedMarkerElement.value.content = null;
-  }
-  pinElement.value = void 0;
-});
+if (import.meta.dev) {
+  console.warn(
+    "[nuxt-scripts] <ScriptGoogleMapsPinElement> was removed in v1. Use the #content slot on <ScriptGoogleMapsMarker> instead. See https://scripts.nuxt.com/docs/migration-guide/v0-to-v1"
+  );
+}
 </script>
+
+<template>
+  <slot />
+</template>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPinElement.vue.d.ts

@@ -1,6 +1,13 @@
-type __VLS_Props = {
-    options?: Omit<google.maps.marker.PinElementOptions, 'map'>;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolygon.d.vue.ts

@@ -1,9 +1,13 @@
 type __VLS_Props = {
+    /**
+     * Configuration options for the polygon overlay.
+     * @see https://developers.google.com/maps/documentation/javascript/reference/polygon#PolygonOptions
+     */
     options?: Omit<google.maps.PolygonOptions, 'map'>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    click: (payload: google.maps.PolyMouseEvent) => any;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     contextmenu: (payload: google.maps.PolyMouseEvent) => any;
+    click: (payload: google.maps.PolyMouseEvent) => any;
     dblclick: (payload: google.maps.PolyMouseEvent) => any;
     drag: (payload: google.maps.MapMouseEvent) => any;
     dragend: (payload: google.maps.MapMouseEvent) => any;
@@ -14,8 +18,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     mouseover: (payload: google.maps.PolyMouseEvent) => any;
     mouseup: (payload: google.maps.PolyMouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onContextmenu?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
+    onClick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onDblclick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onDrag?: ((payload: google.maps.MapMouseEvent) => any) | undefined;
     onDragend?: ((payload: google.maps.MapMouseEvent) => any) | undefined;

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolygon.vue

@@ -1,14 +1,10 @@
-<template>
-
-</template>
-
 <script setup>
-import { inject, onUnmounted } from "vue";
-import { whenever } from "@vueuse/core";
-import { MAP_INJECTION_KEY } from "./ScriptGoogleMaps.vue";
+import { watch } from "vue";
+import { bindGoogleMapsEvents, useGoogleMapsResource } from "./useGoogleMapsResource";
 const props = defineProps({
   options: { type: Object, required: false }
 });
+const emit = defineEmits(["click", "contextmenu", "dblclick", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "drag", "dragend", "dragstart"]);
 const eventsWithPolyMouseEventPayload = [
   "click",
   "contextmenu",
@@ -24,37 +20,26 @@ const eventsWithMapMouseEventPayload = [
   "dragend",
   "dragstart"
 ];
-const emit = defineEmits([]);
-const mapContext = inject(MAP_INJECTION_KEY, void 0);
-let polygon = void 0;
-whenever(() => mapContext?.map.value && mapContext.mapsApi.value, () => {
-  polygon = new mapContext.mapsApi.value.Polygon({
-    map: mapContext.map.value,
-    ...props.options
-  });
-  setupPolygonEventListeners(polygon);
-  whenever(() => props.options, (options) => {
-    polygon?.setOptions(options);
-  }, {
-    deep: true
-  });
-}, {
-  immediate: true,
-  once: true
-});
-onUnmounted(() => {
-  if (!polygon || !mapContext?.mapsApi.value) {
-    return;
+const polygon = useGoogleMapsResource({
+  create({ mapsApi, map }) {
+    const p = new mapsApi.Polygon({ map, ...props.options });
+    bindGoogleMapsEvents(p, emit, {
+      withPayload: [...eventsWithPolyMouseEventPayload, ...eventsWithMapMouseEventPayload]
+    });
+    return p;
+  },
+  cleanup(p, { mapsApi }) {
+    mapsApi.event.clearInstanceListeners(p);
+    p.setMap(null);
   }
-  mapContext.mapsApi.value.event.clearInstanceListeners(polygon);
-  polygon.setMap(null);
 });
-function setupPolygonEventListeners(polygon2) {
-  eventsWithPolyMouseEventPayload.forEach((event) => {
-    polygon2.addListener(event, (payload) => emit(event, payload));
-  });
-  eventsWithMapMouseEventPayload.forEach((event) => {
-    polygon2.addListener(event, (payload) => emit(event, payload));
-  });
-}
+watch(() => props.options, (options) => {
+  if (polygon.value && options) {
+    polygon.value.setOptions(options);
+  }
+}, { deep: true });
 </script>
+
+<template>
+
+</template>

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolygon.vue.d.ts

@@ -1,9 +1,13 @@
 type __VLS_Props = {
+    /**
+     * Configuration options for the polygon overlay.
+     * @see https://developers.google.com/maps/documentation/javascript/reference/polygon#PolygonOptions
+     */
     options?: Omit<google.maps.PolygonOptions, 'map'>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    click: (payload: google.maps.PolyMouseEvent) => any;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     contextmenu: (payload: google.maps.PolyMouseEvent) => any;
+    click: (payload: google.maps.PolyMouseEvent) => any;
     dblclick: (payload: google.maps.PolyMouseEvent) => any;
     drag: (payload: google.maps.MapMouseEvent) => any;
     dragend: (payload: google.maps.MapMouseEvent) => any;
@@ -14,8 +18,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     mouseover: (payload: google.maps.PolyMouseEvent) => any;
     mouseup: (payload: google.maps.PolyMouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onContextmenu?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
+    onClick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onDblclick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onDrag?: ((payload: google.maps.MapMouseEvent) => any) | undefined;
     onDragend?: ((payload: google.maps.MapMouseEvent) => any) | undefined;

package/dist/runtime/components/GoogleMaps/ScriptGoogleMapsPolyline.d.vue.ts

@@ -1,9 +1,13 @@
 type __VLS_Props = {
+    /**
+     * Configuration options for the polyline overlay.
+     * @see https://developers.google.com/maps/documentation/javascript/reference/polygon#PolylineOptions
+     */
     options?: Omit<google.maps.PolylineOptions, 'map'>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    click: (payload: google.maps.PolyMouseEvent) => any;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     contextmenu: (payload: google.maps.PolyMouseEvent) => any;
+    click: (payload: google.maps.PolyMouseEvent) => any;
     dblclick: (payload: google.maps.PolyMouseEvent) => any;
     drag: (payload: google.maps.MapMouseEvent) => any;
     dragend: (payload: google.maps.MapMouseEvent) => any;
@@ -14,8 +18,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     mouseover: (payload: google.maps.PolyMouseEvent) => any;
     mouseup: (payload: google.maps.PolyMouseEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onClick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onContextmenu?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
+    onClick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onDblclick?: ((payload: google.maps.PolyMouseEvent) => any) | undefined;
     onDrag?: ((payload: google.maps.MapMouseEvent) => any) | undefined;
     onDragend?: ((payload: google.maps.MapMouseEvent) => any) | undefined;