@nuxt/scripts 2.0.0-beta.6 → 2.0.0-beta.8

package/dist/runtime/components/MapLibre/types.d.ts

@@ -0,0 +1,275 @@
+import type { GeoJSON } from 'geojson';
+import type * as MapLibre from 'maplibre-gl';
+import type { HTMLAttributes, ReservedProps, ShallowRef } from 'vue';
+import type { ElementScriptTrigger } from '../../types.js';
+/**
+ * Public types for the MapLibre components. They are re-exported from
+ * `@nuxt/scripts` so a consumer can type refs, layer arrays and event payloads
+ * without a deep import.
+ */
+export interface ScriptMapLibreMapProps {
+    /**
+     * Defines when the MapLibre script loads.
+     * @default 'visible'
+     */
+    trigger?: ElementScriptTrigger;
+    /** MapLibre style URL or inline style specification. */
+    mapStyle: string | MapLibre.StyleSpecification;
+    /** Initial and reactively controlled map center. */
+    center: MapLibre.LngLatLike;
+    /** Initial and reactively controlled zoom level. @default 12 */
+    zoom?: number;
+    /** Initial and reactively controlled bearing in degrees. @default 0 */
+    bearing?: number;
+    /** Initial and reactively controlled pitch in degrees. @default 0 */
+    pitch?: number;
+    /** Options passed to `new maplibregl.Map()`. Dedicated props take precedence. */
+    options?: Omit<MapLibre.MapOptions, 'container'>;
+    /** Inject MapLibre's stylesheet when the script begins loading. @default true */
+    injectStyles?: boolean;
+    /** Custom MapLibre stylesheet URL. */
+    stylesheetUrl?: string;
+    /** Worker URL passed to `maplibregl.setWorkerUrl()`. */
+    workerUrl?: string;
+    /** Width reserved before the map loads. @default 640 */
+    width?: number | string;
+    /** Height reserved before the map loads. @default 400 */
+    height?: number | string;
+    /** Accessible name for an interactive map. @default 'Interactive map' */
+    ariaLabel?: string;
+    /** Disable map input and remove it from the accessibility tree when decorative. @default true */
+    interactive?: boolean;
+    /** Attributes applied to the outer layout container. */
+    rootAttrs?: HTMLAttributes & ReservedProps & Record<string, unknown>;
+}
+export interface ScriptMapLibreMapExpose {
+    maplibre: ShallowRef<typeof MapLibre | undefined>;
+    map: ShallowRef<MapLibre.Map | undefined>;
+    load: () => Promise<unknown> | unknown;
+    /** Moves the camera so the bounds fit the viewport. Does nothing before the map exists. */
+    fitBounds: (bounds: MapLibre.LngLatBoundsLike, options?: MapLibre.FitBoundsOptions) => void;
+    /** Animates the camera along a straight path. Does nothing before the map exists. */
+    easeTo: (options: MapLibre.EaseToOptions) => void;
+    /** Animates the camera along a curved flight path. Does nothing before the map exists. */
+    flyTo: (options: MapLibre.FlyToOptions) => void;
+}
+export interface ScriptMapLibreMapEmits {
+    'ready': [payload: ScriptMapLibreMapExpose];
+    'error': [error: Error];
+    /** The map finished its first complete render. Sources and layers are safe to add. */
+    'load': [event: MapLibre.MapEventType['load']];
+    /** The style finished loading. MapLibre drops every source and layer before this fires. */
+    'styleload': [event: MapLibre.MapEventType['style.load']];
+    'click': [event: MapLibre.MapEventType['click']];
+    'move': [event: MapLibre.MapEventType['move']];
+    'moveend': [event: MapLibre.MapEventType['moveend']];
+    'zoom': [event: MapLibre.MapEventType['zoom']];
+    'zoomend': [event: MapLibre.MapEventType['zoomend']];
+    'rotate': [event: MapLibre.MapEventType['rotate']];
+    'rotateend': [event: MapLibre.MapEventType['rotateend']];
+    'pitch': [event: MapLibre.MapEventType['pitch']];
+    'pitchend': [event: MapLibre.MapEventType['pitchend']];
+    'update:center': [center: MapLibre.LngLat];
+    'update:zoom': [zoom: number];
+    'update:bearing': [bearing: number];
+    'update:pitch': [pitch: number];
+}
+export interface ScriptMapLibreMapSlots {
+    default?: () => any;
+    loading?: () => any;
+    awaitingLoad?: () => any;
+    error?: (props: {
+        error: Error;
+    }) => any;
+    placeholder?: () => any;
+    /** Text or links that expose the canvas map's essential information to assistive technology. */
+    description?: () => any;
+}
+/**
+ * Layer kinds a GeoJSON source can render. MapLibre's own style validation
+ * rejects the rest: `hillshade` and `color-relief` need a `raster-dem` source,
+ * `raster` needs raster tiles, and `background` takes no source at all.
+ */
+type GeoJsonLayerType = 'circle' | 'fill' | 'fill-extrusion' | 'heatmap' | 'line' | 'symbol';
+/**
+ * A style layer for this component's source.
+ *
+ * `LayerSpecification` is a union and a plain `Omit` is not distributive, so it
+ * collapses the union to its common keys and drops `filter`. MapLibre's own
+ * `DistributiveOmit` keeps each member, so `type` narrows `filter`, `paint` and
+ * `layout` for that layer kind.
+ *
+ * Only a GeoJSON-compatible layer may leave `source` out. A `raster`,
+ * `hillshade` or `color-relief` layer must name its own source.
+ */
+export type ScriptMapLibreGeoJsonLayer = (MapLibre.DistributiveOmit<Extract<MapLibre.LayerSpecification, {
+    type: GeoJsonLayerType;
+}>, 'source'> & {
+    /** Override the component's source ID for this layer. */
+    source?: string;
+}) | Extract<MapLibre.LayerSpecification, {
+    type: 'color-relief' | 'hillshade' | 'raster';
+}>;
+export interface ScriptMapLibreGeoJsonProps {
+    /** MapLibre source ID. Changing it rebuilds the owned source and layers. */
+    sourceId: string;
+    /** Inline GeoJSON data or a URL returning GeoJSON. */
+    data: GeoJSON | string;
+    /** GeoJSON source options. `type` and `data` are supplied by the component. */
+    sourceOptions?: Omit<MapLibre.GeoJSONSourceSpecification, 'type' | 'data'>;
+    /**
+     * Style layers backed by this source.
+     * A paint, layout or filter change updates the layers in place.
+     * Any other change rebuilds the source and the layers.
+     */
+    layers: ScriptMapLibreGeoJsonLayer[];
+    /** Existing layer ID before which the layers are inserted. */
+    beforeId?: string;
+    /** CSS cursor applied while the pointer is over one of these layers. */
+    cursor?: string;
+}
+export interface ScriptMapLibreGeoJsonEmits {
+    /**
+     * The component could not apply a source or layer, or MapLibre reported an error for one.
+     * MapLibre reports an invalid paint, layout or filter value this way. It does not throw.
+     * A failed rebuild removes the component's own source and layers.
+     * A failed paint, layout or filter update leaves them on the map.
+     */
+    error: [error: Error];
+    /** The pointer clicked one of this component's layers. */
+    click: [event: MapLibre.MapLayerMouseEvent];
+    /**
+     * The pointer double-clicked one of this component's layers.
+     * Call `event.preventDefault()` to stop MapLibre's double-click zoom.
+     */
+    dblclick: [event: MapLibre.MapLayerMouseEvent];
+    /**
+     * The pointer entered this component's layers as a group.
+     * It does not fire again when the pointer moves between touching features.
+     */
+    mouseenter: [event: MapLibre.MapLayerMouseEvent];
+    /**
+     * The pointer moved over a feature in one of this component's layers.
+     * `event.features` lists the features under the pointer, topmost first.
+     */
+    mousemove: [event: MapLibre.MapLayerMouseEvent];
+    /** The pointer left every feature in this component's layers. */
+    mouseleave: [event: MapLibre.MapLayerMouseEvent];
+    /**
+     * The source and layers exist on the map.
+     * Fires after the first add and after every re-add, such as after a style swap.
+     * A re-add clears feature state, so restore it here.
+     */
+    sourceready: [payload: {
+        map: MapLibre.Map;
+        sourceId: string;
+    }];
+}
+export interface ScriptMapLibreGeoJsonResource {
+    map: MapLibre.Map;
+    onLoad: () => void;
+    onStyleLoad: () => void;
+    onStyleDataLoading: () => void;
+    onIdle: () => void;
+    onError: (event: {
+        error: Error | {
+            message: string;
+        };
+    }) => void;
+}
+export interface ScriptMapLibreMarkerProps {
+    /** Reactive marker position in `[longitude, latitude]` order. */
+    position: MapLibre.LngLatLike;
+    /** Accessible name for the marker element. */
+    ariaLabel?: string;
+    /** Tooltip text for the marker element. */
+    title?: string;
+    /** Options passed to `new maplibregl.Marker()`. Options with public setters also update reactively. */
+    options?: MapLibre.MarkerOptions;
+}
+export interface ScriptMapLibreMarkerEmits {
+    click: [event: MouseEvent];
+    dragstart: [event: MapLibre.Event];
+    drag: [event: MapLibre.Event];
+    dragend: [event: MapLibre.Event];
+}
+export interface ScriptMapLibrePopupProps {
+    /** Position for a standalone popup. Omit when nested inside a marker. */
+    position?: MapLibre.LngLatLike;
+    /** Whether the popup is open. @default false */
+    open?: boolean;
+    /** Options passed to `new maplibregl.Popup()`. Options with public setters also update reactively. */
+    options?: MapLibre.PopupOptions;
+}
+export interface ScriptMapLibrePopupEmits {
+    open: [event: MapLibre.Event];
+    close: [event: MapLibre.Event];
+}
+export interface ScriptMapLibreNavigationControlProps {
+    /** Position of the navigation control. */
+    position?: MapLibre.ControlPosition;
+    /** Options passed to `new maplibregl.NavigationControl()`. */
+    options?: MapLibre.NavigationControlOptions;
+}
+export interface ScriptMapLibreScaleControlProps {
+    /** Position of the scale control. MapLibre places it bottom-left by default. */
+    position?: MapLibre.ControlPosition;
+    /**
+     * Options passed to `new maplibregl.ScaleControl()`.
+     * `unit` also updates reactively through `setUnit()`.
+     */
+    options?: MapLibre.ScaleControlOptions;
+}
+export interface ScriptMapLibreGeolocateControlProps {
+    /** Position of the geolocate control. */
+    position?: MapLibre.ControlPosition;
+    /** Options passed to `new maplibregl.GeolocateControl()`. */
+    options?: MapLibre.GeolocateControlOptions;
+}
+export interface ScriptMapLibreGeolocateControlEmits {
+    /** The Geolocation API returned a position. */
+    geolocate: [event: MapLibre.GeolocateControlEventType['geolocate']];
+    /**
+     * The Geolocation API returned an error.
+     * `code` 1 means the user denied permission. MapLibre then disables the button.
+     */
+    error: [event: MapLibre.GeolocateControlEventType['error']];
+    /** The position is outside the map's `maxBounds`. */
+    outofmaxbounds: [event: MapLibre.GeolocateControlEventType['outofmaxbounds']];
+    /** The control entered the active lock state. Needs `trackUserLocation`. */
+    trackuserlocationstart: [event: MapLibre.GeolocateControlEventType['trackuserlocationstart']];
+    /** The control left the active lock state. Needs `trackUserLocation`. */
+    trackuserlocationend: [event: MapLibre.GeolocateControlEventType['trackuserlocationend']];
+    /** The user clicked the button in the active lock state. */
+    userlocationfocus: [event: MapLibre.GeolocateControlEventType['userlocationfocus']];
+    /** The user moved the map in the active lock state. */
+    userlocationlostfocus: [event: MapLibre.GeolocateControlEventType['userlocationlostfocus']];
+    /**
+     * Geolocation cannot work in this browser.
+     * `permission-denied` means the user blocked it before the control loaded.
+     * MapLibre disables the button and fires no `error` event in both cases.
+     */
+    unavailable: [reason: 'unsupported' | 'permission-denied'];
+}
+export interface ScriptMapLibreFullscreenControlProps {
+    /** Position of the fullscreen control. */
+    position?: MapLibre.ControlPosition;
+    /** Options passed to `new maplibregl.FullscreenControl()`. */
+    options?: MapLibre.FullscreenControlOptions;
+}
+export interface ScriptMapLibreFullscreenControlEmits {
+    /** The map entered fullscreen mode. */
+    fullscreenstart: [event: MapLibre.FullscreenControlEventType['fullscreenstart']];
+    /** The map left fullscreen mode. */
+    fullscreenend: [event: MapLibre.FullscreenControlEventType['fullscreenend']];
+}
+export interface ScriptMapLibreAttributionControlProps {
+    /** Position of the attribution control. MapLibre places it bottom-right by default. */
+    position?: MapLibre.ControlPosition;
+    /**
+     * Options passed to `new maplibregl.AttributionControl()`.
+     * Source attribution from the style and tiles always shows. `customAttribution` only adds text.
+     */
+    options?: MapLibre.AttributionControlOptions;
+}
+export {};

package/dist/runtime/components/MapLibre/useMapLibreResource.d.ts

@@ -12,12 +12,19 @@ export interface MapLibreResourceContext {
     map: MapLibre.Map;
     maplibre: typeof MapLibre;
 }
+/**
+ * Logs a MapLibre resource failure and hands it to the owning component, so the
+ * consumer can surface it instead of only seeing a console message.
+ */
+export declare function reportMapLibreResourceError(error: unknown, onError?: (error: Error) => void): Error;
 /**
  * Creates a MapLibre resource after its parent map and any component-specific
  * DOM refs are ready, then removes it synchronously during unmount.
  */
-export declare function useMapLibreResource<T>({ ready, create, cleanup, }: {
+export declare function useMapLibreResource<T>({ ready, create, cleanup, onError, }: {
     ready?: () => boolean;
     create: (context: MapLibreResourceContext) => T;
     cleanup: (resource: T, context: MapLibreResourceContext) => void;
+    /** Called when `create` throws, after the failure is logged. */
+    onError?: (error: Error) => void;
 }): ShallowRef<T | undefined>;

package/dist/runtime/components/MapLibre/useMapLibreResource.js

@@ -1,10 +1,17 @@
 import { inject, onUnmounted, shallowRef, watch } from "vue";
 export const MAPLIBRE_MAP_INJECTION_KEY = Symbol("maplibre-map");
 export const MAPLIBRE_MARKER_INJECTION_KEY = Symbol("maplibre-marker");
+export function reportMapLibreResourceError(error, onError) {
+  const failure = error instanceof Error ? error : new Error("MapLibre resource creation failed", { cause: error });
+  console.error("[nuxt-scripts] MapLibre resource creation failed:", error);
+  onError?.(failure);
+  return failure;
+}
 export function useMapLibreResource({
   ready,
   create,
-  cleanup
+  cleanup,
+  onError
 }) {
   const mapContext = inject(MAPLIBRE_MAP_INJECTION_KEY, void 0);
   const resource = shallowRef();
@@ -23,7 +30,7 @@ export function useMapLibreResource({
         resourceContext = { map, maplibre };
         resource.value = create(resourceContext);
       } catch (error) {
-        console.error("[nuxt-scripts] MapLibre resource creation failed:", error);
+        reportMapLibreResourceError(error, onError);
       } finally {
         creating = false;
       }

package/dist/runtime/registry/pulse-analytics.d.ts

@@ -0,0 +1,32 @@
+import type { RegistryScriptInput } from '#nuxt-scripts/types';
+import { PulseAnalyticsOptions } from './schemas.js';
+export { PulseAnalyticsOptions };
+export type PulseAnalyticsInput = RegistryScriptInput<typeof PulseAnalyticsOptions, false>;
+export interface PulseAnalyticsApi {
+    /**
+     * Records a custom event.
+     * @param name Event name: letters, numbers and underscores, up to 64 characters.
+     * Trimmed and lowercased before storage.
+     * @param props Optional properties. Values must be strings; a number or boolean
+     * rejects the whole event.
+     * @param revenue Optional monetary value, zero or greater.
+     * @see https://docs.ciphera.net/pulse/custom-events
+     */
+    track: (name: string, props?: Record<string, string>, revenue?: number) => void;
+    /**
+     * The current pathname as Pulse records it: trailing slash stripped, root kept
+     * as `/`. Returns `null` until the tracker has loaded.
+     */
+    cleanPath: () => string | null;
+}
+declare global {
+    interface Window {
+        pulse: PulseAnalyticsApi;
+        /**
+         * Set by the tracker before its opt-out checks run. Present without
+         * `pulse.track` means the tracker ran and declined to record.
+         */
+        __pulseInstalled?: boolean;
+    }
+}
+export declare function useScriptPulseAnalytics<T extends PulseAnalyticsApi>(_options?: PulseAnalyticsInput): import("#nuxt-scripts/types").UseScriptContext<T>;

package/dist/runtime/registry/pulse-analytics.js

@@ -0,0 +1,80 @@
+import { useRegistryScript } from "../utils.js";
+import { PulseAnalyticsOptions } from "./schemas.js";
+export { PulseAnalyticsOptions };
+const PULSE_QUEUE_KEY = Symbol.for("nuxt-scripts.pulse-queue");
+const MAX_QUEUED_EVENTS = 100;
+function getPulseState() {
+  if (typeof window === "undefined")
+    return;
+  const g = globalThis;
+  if (!g[PULSE_QUEUE_KEY]) {
+    g[PULSE_QUEUE_KEY] = { queue: [], flushed: false, declined: false };
+  }
+  return g[PULSE_QUEUE_KEY];
+}
+function isPulseReady() {
+  return typeof window !== "undefined" && typeof window.pulse?.track === "function";
+}
+function hasPulseDeclined() {
+  return typeof window !== "undefined" && window.__pulseInstalled === true && !isPulseReady();
+}
+export function useScriptPulseAnalytics(_options) {
+  const flushQueue = () => {
+    const state = getPulseState();
+    if (!state || state.flushed || state.declined)
+      return;
+    if (hasPulseDeclined()) {
+      state.declined = true;
+      state.queue.length = 0;
+      return;
+    }
+    if (!isPulseReady())
+      return;
+    state.flushed = true;
+    while (state.queue.length > 0) {
+      const args = state.queue.shift();
+      try {
+        window.pulse.track(...args);
+      } catch {
+      }
+    }
+  };
+  const track = (name, props, revenue) => {
+    if (isPulseReady()) {
+      window.pulse.track(name, props, revenue);
+      return;
+    }
+    const state = getPulseState();
+    if (!state || state.declined)
+      return;
+    if (hasPulseDeclined()) {
+      state.declined = true;
+      state.queue.length = 0;
+      return;
+    }
+    if (state.queue.length < MAX_QUEUED_EVENTS)
+      state.queue.push([name, props, revenue]);
+  };
+  return useRegistryScript("pulseAnalytics", (options) => ({
+    scriptInput: {
+      "src": "https://js.ciphera.net/script.js",
+      "data-domain": options.domain,
+      "data-api": options.apiUrl || void 0,
+      // Presence flags: the tracker reads them with hasAttribute(), so a
+      // rendered `data-no-scroll="false"` would still switch scroll tracking off.
+      "data-no-scroll": options.trackScroll === false ? "" : void 0,
+      "data-no-outbound": options.trackOutbound === false ? "" : void 0,
+      "data-no-downloads": options.trackDownloads === false ? "" : void 0
+    },
+    schema: import.meta.dev ? PulseAnalyticsOptions : void 0,
+    scriptOptions: {
+      use() {
+        flushQueue();
+        return {
+          track,
+          cleanPath: () => window.pulse?.cleanPath?.() ?? null
+        };
+      }
+    }
+  }), _options);
+}

package/dist/runtime/registry/schemas.d.ts

@@ -791,6 +791,34 @@ export declare const RedditPixelOptions: import("valibot").ObjectSchema<{
      */
     readonly id: import("valibot").StringSchema<undefined>;
 }, undefined>;
+export declare const PulseAnalyticsOptions: import("valibot").ObjectSchema<{
+    /**
+     * The site domain as registered in Pulse.
+     * @see https://docs.ciphera.net/pulse/script-installation
+     */
+    readonly domain: import("valibot").StringSchema<undefined>;
+    /**
+     * The API origin the tracker posts events to. Only needed for a self-hosted
+     * or reverse-proxied Pulse API.
+     * @default 'https://pulse-api.ciphera.net'
+     */
+    readonly apiUrl: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+    /**
+     * Record scroll depth.
+     * @default true
+     */
+    readonly trackScroll: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Record outbound link clicks as `outbound_link` events.
+     * @default true
+     */
+    readonly trackOutbound: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    /**
+     * Record file download clicks as `file_download` events.
+     * @default true
+     */
+    readonly trackDownloads: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+}, undefined>;
 export declare const RybbitAnalyticsOptions: import("valibot").ObjectSchema<{
     /**
      * Your Rybbit site ID.
@@ -1188,6 +1216,20 @@ export declare const StripeOptions: import("valibot").ObjectSchema<{
      */
     readonly version: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").LiteralSchema<"v3", undefined>, import("valibot").LiteralSchema<"acacia", undefined>, import("valibot").LiteralSchema<"basil", undefined>, import("valibot").LiteralSchema<"clover", undefined>, import("valibot").LiteralSchema<"dahlia", undefined>, import("valibot").StringSchema<undefined>], undefined>, undefined>;
 }, undefined>;
+export declare const TawkToOptions: import("valibot").ObjectSchema<{
+    /**
+     * Your Tawk.to property ID: the first path segment of the widget embed URL
+     * `https://embed.tawk.to/<propertyId>/<widgetId>`.
+     * @see https://dashboard.tawk.to/
+     */
+    readonly propertyId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
+    /**
+     * Your Tawk.to widget ID: the second path segment of the widget embed URL
+     * `https://embed.tawk.to/<propertyId>/<widgetId>`.
+     * @see https://dashboard.tawk.to/
+     */
+    readonly widgetId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
 export declare const TikTokPixelOptions: import("valibot").ObjectSchema<{
     /**
      * Your TikTok Pixel ID.

package/dist/runtime/registry/schemas.js

@@ -753,6 +753,34 @@ export const RedditPixelOptions = object({
    */
   id: string()
 });
+export const PulseAnalyticsOptions = object({
+  /**
+   * The site domain as registered in Pulse.
+   * @see https://docs.ciphera.net/pulse/script-installation
+   */
+  domain: string(),
+  /**
+   * The API origin the tracker posts events to. Only needed for a self-hosted
+   * or reverse-proxied Pulse API.
+   * @default 'https://pulse-api.ciphera.net'
+   */
+  apiUrl: optional(string()),
+  /**
+   * Record scroll depth.
+   * @default true
+   */
+  trackScroll: optional(boolean()),
+  /**
+   * Record outbound link clicks as `outbound_link` events.
+   * @default true
+   */
+  trackOutbound: optional(boolean()),
+  /**
+   * Record file download clicks as `file_download` events.
+   * @default true
+   */
+  trackDownloads: optional(boolean())
+});
 export const RybbitAnalyticsOptions = object({
   /**
    * Your Rybbit site ID.
@@ -1107,6 +1135,20 @@ export const StripeOptions = object({
    */
   version: optional(union([literal("v3"), literal("acacia"), literal("basil"), literal("clover"), literal("dahlia"), string()]))
 });
+export const TawkToOptions = object({
+  /**
+   * Your Tawk.to property ID: the first path segment of the widget embed URL
+   * `https://embed.tawk.to/<propertyId>/<widgetId>`.
+   * @see https://dashboard.tawk.to/
+   */
+  propertyId: pipe(string(), minLength(1)),
+  /**
+   * Your Tawk.to widget ID: the second path segment of the widget embed URL
+   * `https://embed.tawk.to/<propertyId>/<widgetId>`.
+   * @see https://dashboard.tawk.to/
+   */
+  widgetId: pipe(string(), minLength(1))
+});
 export const TikTokPixelOptions = object({
   /**
    * Your TikTok Pixel ID.