@maptiler/sdk 5.0.0-rc.2 → 5.0.0-rc.4

package/dist/Marker/marker-transitions.d.ts

@@ -0,0 +1,29 @@
+import { LngLat } from '../index';
+import { MaptilerAnimation } from '../MaptilerAnimation';
+import { MarkerTransitionSpec, Vector2 } from './types';
+import { LifecycleAnimationValue } from './marker-animation-presets';
+/** Bridges a transitionable property's real value to/from the flat numeric props {@link MaptilerAnimation} interpolates between. */
+export type TransitionValueCodec<T> = {
+    toNumeric(value: T): Record<string, number>;
+    fromNumeric(props: Record<string, number>): T;
+};
+export declare const scaleTransitionCodec: TransitionValueCodec<Vector2>;
+export declare const rotationTransitionCodec: TransitionValueCodec<number>;
+export declare const opacityTransitionCodec: TransitionValueCodec<number>;
+/** Bridges an `enter`/`exit` preset's combined opacity/scale/lift state to the numeric props {@link MaptilerAnimation} interpolates between. */
+export declare const lifecycleTransitionCodec: TransitionValueCodec<LifecycleAnimationValue>;
+export declare const positionTransitionCodec: TransitionValueCodec<LngLat>;
+export declare const colorTransitionCodec: TransitionValueCodec<string | undefined>;
+export type PropertyTransitionHandlers<T> = {
+    codec: TransitionValueCodec<T>;
+    onUpdate: (value: T) => void;
+    onStart: () => void;
+    onEnd: (value: T) => void;
+};
+/**
+ * Eases `from` to `to` over `spec`'s duration/easing/delay via a one-shot
+ * {@link MaptilerAnimation}, calling `onUpdate` every frame and `onEnd` once
+ * with the exact target value. The returned animation is already playing;
+ * callers own its lifetime — `.destroy()` it to cancel.
+ */
+export declare function runPropertyTransition<T>(from: T, to: T, spec: MarkerTransitionSpec, handlers: PropertyTransitionHandlers<T>): MaptilerAnimation;

package/dist/Marker/types.d.ts

@@ -0,0 +1,458 @@
+import { Event as EventML, LngLatLike, MarkerEventType, MarkerOptions } from 'maplibre-gl';
+import { EasingFunctionName } from '../MaptilerAnimation/types';
+import { Marker } from './Marker';
+import { MapTilerMarkerIcon } from './marker-icons';
+/** Visual shape of the marker body. */
+export type MapTilerMarkerShape = "circle" | "square" | "bubble-circle" | "bubble-square" | "maptiler" | "maptiler-full";
+/** T-shirt size for the marker. */
+export type MapTilerMarkerSize = "xs" | "s" | "m" | "l";
+/** Drop-shadow intensity applied beneath the marker. */
+export type MapTilerMarkerShadow = "none" | "soft" | "medium" | "strong";
+export type { MapTilerMarkerIcon } from './marker-icons';
+/** Behaviour when this marker spatially overlaps another. */
+export declare const CollisionBehaviour: {
+    /** No collision detection — marker is always shown. */
+    readonly ALWAYS_SHOW: "always-show";
+    /** Marker is hidden when it collides with a higher-priority marker. */
+    readonly HIDE_BY_PRIORITY: "hide-by-priority";
+    /** Marker is minimised to a simple point/circle when colliding with a higher-priority marker. */
+    readonly MINIMIZE_BY_PRIORITY: "minimize-by-priority";
+};
+export type CollisionBehaviour = (typeof CollisionBehaviour)[keyof typeof CollisionBehaviour];
+export type Vector2 = [number, number];
+/**
+ * Kind of spatial collision between two markers.
+ * - `overlap` — the markers' boxes intersect.
+ * - `proximity` — the boxes are within the configured proximity padding
+ *   (a superset of `overlap`).
+ */
+export type MarkerCollisionKind = "overlap" | "proximity";
+/**
+ * Payload of the `markeroverlap` / `markerproximity` events.
+ *
+ * Emitted on state change only: a marker fires when counterparts *enter* or
+ * *exit* collision with it, never for collisions that persist unchanged
+ * between passes.
+ */
+export type MarkerCollisionEventData = {
+    kind: MarkerCollisionKind;
+    /** Markers that started colliding with this marker in this pass. */
+    entered: Marker[];
+    /** Markers that stopped colliding with this marker in this pass (may already be removed from the map). */
+    exited: Marker[];
+    /** All markers currently colliding with this marker. */
+    current: Marker[];
+};
+/**
+ * Sets of mutually-colliding markers from the latest detection pass —
+ * connected components of the pairwise collision graph, with no
+ * winner/loser resolution applied.
+ */
+export type MarkerCollisionGroups = {
+    overlap: Marker[][];
+    proximity: Marker[][];
+};
+/**
+ * How precisely marker collision boxes track rotation.
+ * - `high` (default) — rotated markers are tested with their actual rotated
+ *   box (separating-axis test), so collisions match the rendered footprint.
+ * - `low` — rotated markers are tested with the upright box enclosing the
+ *   rotated one. Cheaper per pair, but over-reports collisions for elongated
+ *   markers at strong rotations (never misses a real one).
+ */
+export type MarkerCollisionAccuracy = "low" | "high";
+/** Per-map configuration of the marker collision engine. */
+export type MarkerCollisionOptions = {
+    /** Distance in CSS px within which two markers count as "in proximity". Overlap always uses 0. */
+    proximityPadding?: number;
+    /** Collision box accuracy for rotated markers. Defaults to `high`. */
+    accuracy?: MarkerCollisionAccuracy;
+    /**
+     * Default collision behaviour for every marker on the map. A marker's own
+     * `collisionBehaviour` option overrides it. Defaults to `always-show`
+     * (nothing is ever hidden until a behaviour is opted into).
+     */
+    behaviour?: CollisionBehaviour;
+    /**
+     * Duration in milliseconds of the hide/show/minimize fade transition
+     * markers go through under collision behaviours. Defaults to `150`.
+     */
+    transitionDuration?: number;
+    /**
+     * CSS easing function for the fade transition (e.g. `"ease"`,
+     * `"ease-in-out"`, `"linear"`, or a `cubic-bezier(...)` expression).
+     * Defaults to `"ease"`.
+     */
+    transitionEasing?: string;
+};
+/**
+ * How the collision engine is currently displaying a marker.
+ * - `visible` — displayed normally.
+ * - `hidden` — hidden because it lost to a higher-priority marker
+ *   (`hide-by-priority`), or sits outside the viewport (off-screen markers
+ *   are excluded from collision processing and hidden regardless of
+ *   behaviour).
+ * - `minimized` — displayed as its minimized variant (`minimize-by-priority`).
+ */
+export type MarkerCollisionDisplayState = "visible" | "hidden" | "minimized";
+/**
+ * Visual overrides applied while a `minimize-by-priority` marker is
+ * minimized. Merged over the default minimized appearance (`{ size: "xs" }`,
+ * which renders the marker as a small dot in its own colours). The marker's
+ * regular values are restored when it un-minimizes.
+ *
+ * Only affects markers built by the SVG system — markers constructed with a
+ * custom `element` minimize to a plain dot, of which only the colour fields
+ * apply (consumed as CSS custom properties).
+ */
+export type MarkerMinimizedOptions = Pick<MapTilerMarkerBaseOptions, "shape" | "size" | "innerColor" | "outerColor" | "contentColor" | "outline" | "outlineColor" | "shadow" | "opacity">;
+/**
+ * MapLibre-style expression that resolves to a numeric priority.
+ * Evaluated by the collision engine, not applied directly to the DOM.
+ */
+export type MarkerPriorityExpression = unknown[];
+/**
+ * What {@link Marker.setAltitude}'s meters are measured from.
+ * - `ground` (default) — above the terrain surface under the marker's
+ *   lngLat, via `map.queryTerrainElevation()`. Falls back to the flat
+ *   mercator plane (sea level) when terrain isn't enabled/loaded — so this
+ *   is a safe default whether or not the map has terrain.
+ * - `sea` — above sea level / the flat mercator plane outright, ignoring
+ *   terrain entirely, even when it's enabled.
+ * @experimental
+ */
+export type AltitudeReference = "ground" | "sea";
+/**
+ * Options for {@link Marker.setAltitude}.
+ * @experimental
+ */
+export type SetAltitudeOptions = {
+    /** What the altitude is measured from. Defaults to `"ground"`. */
+    relativeTo?: AltitudeReference;
+};
+/**
+ * Configures the optional dashed line from a marker down (or up) to its ground point. Off by default — see {@link Marker.setGroundLine}.
+ * @experimental
+ */
+export type GroundLineOptions = {
+    /**
+     * Extra class applied to the ground-line element alongside the default
+     * `maptiler-marker-groundline`. Style colour/width/dashing from your own
+     * stylesheet using either selector — the line carries no inline colour so
+     * your CSS always wins (see the `:where()`-scoped default in the SDK
+     * stylesheet, kept at zero specificity for exactly this reason).
+     */
+    className?: string;
+};
+/**
+ * Predefined `enter` animation types.
+ * - `fade` — opacity only.
+ * - `grow` — uniform scale from nothing, plus fade.
+ * - `pop` — uniform scale from nothing with a springy overshoot, plus fade.
+ * - `drop` — slides straight down into place, plus fade.
+ * - `bounce` — slides down into place with a bounce-settle, fully opaque throughout.
+ *
+ * See `marker-animation-presets.ts` for each preset's exact motion/easing config.
+ */
+export type EnterAnimationPreset = "grow" | "drop" | "pop" | "bounce" | "fade";
+/**
+ * Predefined `exit` animation types.
+ * - `fade` — opacity only.
+ * - `shrink` — uniform scale to nothing, fully opaque throughout.
+ * - `pop` — scale to nothing combined with a fade, springy overshoot.
+ * - `explode` — scales up (2x) while fading out.
+ *
+ * See `marker-animation-presets.ts` for each preset's exact motion/easing config.
+ */
+export type ExitAnimationPreset = "shrink" | "fade" | "pop" | "explode";
+/**
+ * Predefined `idle` animation types — each loops a single channel out and
+ * back to rest once per iteration, peaking at the midpoint (`delta` `0.5`).
+ * - `pulsescale` — scales up and back down, ~1 cycle/second by default.
+ * - `pulseopacity` — dims and back to full opacity, ~1 cycle/second by default.
+ * - `ring` — a rotational shake (several alternating wiggles) clustered around the midpoint, every few seconds by default.
+ * - `bounce` — a vertical hop clustered around the midpoint, every few seconds by default.
+ *
+ * See `marker-animation-presets.ts` for each preset's exact keyframe config.
+ */
+export type IdleAnimationPreset = "pulsescale" | "ring" | "pulseopacity" | "bounce";
+/** Fields shared by every enter/exit/idle animation spec, whether preset-based or {@link MarkerCustomAnimationOptions}. */
+export type MarkerAnimationBase = {
+    /** Overrides the preset's default easing. Defaults to `"Linear"`. Also applies to a `custom` animation's `alpha`. */
+    easing?: EasingFunctionName;
+    /** Duration in milliseconds. Defaults to `1000`. */
+    duration?: number;
+    /** Delay before the animation starts, in milliseconds. Defaults to `0`. */
+    delay?: number;
+};
+/** Configures a marker's `enter`/`exit`/`idle` animation via a predefined preset. */
+export type MarkerPresetAnimationOptions<Preset extends string> = MarkerAnimationBase & {
+    /** Predefined animation type. */
+    preset: Preset;
+    custom?: never;
+    /**
+     * Scales the preset's motion from rest (`0`) up to its full designed
+     * displacement (`1`, the default) — values beyond `1` exaggerate it.
+     * Has no effect on presets with no independent "how far" axis.
+     */
+    magnitude?: number;
+};
+/** Configures a marker's `enter`/`exit`/`idle` animation via a custom per-frame callback instead of a preset. */
+export type MarkerCustomAnimationOptions = MarkerAnimationBase & {
+    preset?: never;
+    magnitude?: never;
+    /**
+     * Called every frame with the already-eased progress (`0`–`1`, `easing`
+     * already applied) and the marker being animated. For `enter`, `0` is the
+     * starting (hidden) state and `1` is fully shown; for `exit`, `0` is fully
+     * shown and `1` is the end (hidden) state; for `idle`, `alpha` resets to
+     * `0` at the start of every loop iteration.
+     */
+    custom: (alpha: number, marker: Marker) => void;
+};
+/** Configures a marker's `enter` or `exit` lifecycle animation. */
+export type MarkerAnimationOptions<Preset extends string = EnterAnimationPreset | ExitAnimationPreset> = MarkerPresetAnimationOptions<Preset> | MarkerCustomAnimationOptions;
+/** Configures a marker's `idle` lifecycle animation. */
+export type MarkerIdleAnimationOptions = MarkerAnimationOptions<IdleAnimationPreset> & {
+    /** Number of loop iterations. Omit, or pass `Infinity`, to loop continuously. */
+    iterations?: number;
+};
+/**
+ * Lifecycle animations played as a marker enters, idles on, and exits the map.
+ */
+export type MapTilerMarkerAnimations = {
+    /** Played once the marker is added to a map. */
+    enter?: MarkerAnimationOptions<EnterAnimationPreset>;
+    /**
+     * Played when `remove()` is called. The marker stays on the map, still
+     * receiving updates, until this animation finishes.
+     */
+    exit?: MarkerAnimationOptions<ExitAnimationPreset>;
+    /**
+     * Looped while the marker sits on the map, after `enter` finishes (or
+     * immediately, if no `enter` is configured).
+     */
+    idle?: MarkerIdleAnimationOptions;
+};
+/**
+ * Event fired by a marker's lifecycle animations — `enter`/`exit` fire
+ * `start`/`end` once each; `idle` additionally fires `iteration` once per loop.
+ */
+export type MarkerLifecycleAnimationEventData = {
+    type: "enteranimationstart" | "enteranimationend" | "exitanimationstart" | "exitanimationend" | "idleanimationstart" | "idleanimationiteration" | "idleanimationend";
+    target: Marker;
+    /** The preset configured for the phase that fired this event, or `"custom"` for a {@link MarkerCustomAnimationOptions} animation. */
+    preset: EnterAnimationPreset | ExitAnimationPreset | IdleAnimationPreset | "custom";
+};
+/** Marker properties that can be eased from their old value to a new one instead of snapping. */
+export type MarkerTransitionProperty = "position" | "scale" | "rotation" | "outerColor" | "innerColor" | "contentColor" | "outlineColor";
+/**
+ * Configures how a transitionable property eases to a newly-set value.
+ * `[duration, easing?, delay?]`, all in milliseconds except `easing`.
+ * `easing` is any {@link EasingFunctionName}, defaulting to `"Linear"` when omitted.
+ * Defaults to no delay when omitted.
+ */
+export type MarkerTransitionSpec = [duration: number, easing?: EasingFunctionName, delay?: number];
+/** Per-property transition configuration, keyed by {@link MarkerTransitionProperty}. */
+export type MapTilerMarkerTransitions = Partial<Record<MarkerTransitionProperty, MarkerTransitionSpec>>;
+/**
+ * Event fired by a marker's `transitionstart` / `transitionend` — the same
+ * shape as MapLibre's own marker events (`type`, `target`), plus `props`.
+ */
+export type MarkerTransitionEventData = {
+    type: "transitionstart" | "transitionend";
+    target: Marker;
+    /**
+     * The property being transitioned, keyed to its value at the time of the
+     * event — the value it's easing from on `transitionstart`, the value it
+     * reached on `transitionend`.
+     */
+    props: Partial<Record<MarkerTransitionProperty, unknown>>;
+};
+/**
+ * Marker content driven by a built-in icon, drawn in the content colour and
+ * sized to the marker (16 / 12 / 8 px for `l` / `m` / `s`; `xs` shows no content).
+ */
+export type MarkerContentTypeIcon = {
+    /** Name of a built-in icon. */
+    icon: MapTilerMarkerIcon;
+    url?: never;
+    template?: never;
+    templateParams?: never;
+    element?: never;
+};
+/** Marker content driven by an image or SVG URL. */
+export type MarkerContentTypeImageUrl = {
+    /** URL of an image or SVG to render as marker content. */
+    url: string;
+    icon?: never;
+    template?: never;
+    templateParams?: never;
+    element?: never;
+};
+/** Marker content driven by a named template and its parameters. */
+export type MarkerContentTypeTemplate = {
+    /** Identifier for a registered template factory function. */
+    template: string;
+    /** Parameters forwarded to the template config function. */
+    templateParams?: Record<string, number | string>;
+    icon?: never;
+    url?: never;
+    element?: never;
+};
+/**
+ * Marker content driven by an existing DOM or SVG element.
+ * Useful when content is managed by a rendering engine such as React.
+ */
+export type MarkerContentTypeElement = {
+    /** An HTML or SVG element to use as marker content. */
+    element: HTMLElement | SVGElement;
+    icon?: never;
+    url?: never;
+    template?: never;
+    templateParams?: never;
+};
+/** Marker with no explicit content — uses the default marker appearance. */
+export type MarkerContentTypeNone = {
+    icon?: never;
+    url?: never;
+    template?: never;
+    templateParams?: never;
+    element?: never;
+};
+export type MarkerContent = MarkerContentTypeNone | MarkerContentTypeIcon | MarkerContentTypeImageUrl | MarkerContentTypeTemplate | MarkerContentTypeElement;
+/** UI "state" types that can restyle a marker. */
+export type MapTilerMarkerUIStateName = "hover" | "focus" | "active" | "dragging";
+/** Property overrides applied while a UI state is active. Keys are any settable marker property (e.g. `shape`, `opacity`, `scale`). */
+export type UIStateSpec = Partial<MapTilerMarkerElementProps>;
+/** Per-state property overrides, keyed by UI state name. */
+export type MapTilerMarkerUIStates = Partial<Record<MapTilerMarkerUIStateName, UIStateSpec>>;
+export type MapTilerMarkerBaseOptions = Omit<MarkerOptions, "scale" | "opacity" | "opacityWhenCovered" | "color"> & {
+    /** Position of the marker. Can also be set later with `setLngLat()`. */
+    lngLat?: LngLatLike;
+    /** Visual shape of the marker body. Defaults to `"maptiler"`. */
+    shape?: MapTilerMarkerShape;
+    /** Size of the marker. */
+    size?: MapTilerMarkerSize;
+    /**
+     * Fill colour of the inner area of the marker. Defaults to a colour chosen
+     * for the current map style, re-resolved whenever the style changes.
+     * Setting it explicitly makes the colour static.
+     */
+    innerColor?: string;
+    /** Fill colour of the outer area (body/border) of the marker. Defaults to the current map style's colour, like `innerColor`. */
+    outerColor?: string;
+    /** Colour applied to the marker content (icon, text, etc.). Defaults to the current map style's colour, like `innerColor`. */
+    contentColor?: string;
+    /** Outline width in pixels. Pass `true` to use the default width. */
+    outline?: true | number;
+    /** Colour of the marker outline. Defaults to the current map style's colour, like `innerColor`. */
+    outlineColor?: string;
+    /** Drop-shadow intensity. Defaults per size: `"strong"` at `l`, `"medium"` at `m`, `"soft"` at `s` and `xs`; use `"none"` to disable. */
+    shadow?: MapTilerMarkerShadow;
+    opacity?: number;
+    opacityWhenCovered?: number;
+    /**
+     * Optional marker name, added as a CSS class on the marker element.
+     * Must be safe for use as a CSS class name.
+     */
+    name?: string;
+    /** Applied to the `title` attribute of the marker's root element (native tooltip). */
+    title?: string;
+    /** Text content rendered inside the marker body. */
+    content?: string;
+    /** HTML attributes applied directly to the marker's root element. */
+    htmlAttributes?: Record<string, number | string>;
+    /** 2-D scale of the marker as `[x, y]`. Defaults to `[1, 1]`. */
+    scale?: Vector2;
+    /** Initial visibility of the marker. Defaults to `true`. TODO: not implemented yet. */
+    visible?: boolean;
+    /** Rendering priority used for collision detection. Accepts a numeric value or a MapLibre-style expression. */
+    priority?: number | MarkerPriorityExpression;
+    /** Lifecycle animations played as the marker enters, idles on, and exits the map. */
+    animations?: MapTilerMarkerAnimations;
+    /**
+     * Per-property easing applied when a transitionable property (`position`,
+     * `scale`, `rotation`, or a colour) is next set, instead of the change
+     * snapping immediately. See {@link setTransitionForProperty}.
+     */
+    transitions?: MapTilerMarkerTransitions;
+    /** Arbitrary user-defined data attached to the marker instance. */
+    userData?: Record<string, unknown>;
+    /** Behaviour when this marker spatially overlaps another. Overrides the map-level default (see `MarkerCollisionOptions`). */
+    collisionBehaviour?: CollisionBehaviour;
+    /**
+     * Visual overrides applied while the marker is minimized by the
+     * `minimize-by-priority` collision behaviour. Merged over the default
+     * minimized appearance (`{ size: "xs" }`).
+     */
+    minimizedOptions?: MarkerMinimizedOptions;
+    /** When `true`, renders a debug overlay showing the marker's bounding box and center point. */
+    debug?: boolean;
+    /**
+     * Collision detection radius in pixels.
+     * `0` means the marker's bounding box is used.
+     */
+    collisionRadius?: number;
+    /**
+     * Per-state property overrides applied while the marker is hovered,
+     * focused, active (pointer down), or being dragged.
+     */
+    states?: MapTilerMarkerUIStates;
+};
+/**
+ * Subset of {@link MapTilerMarkerBaseOptions} that applies when an external
+ * DOM/SVG element is supplied as marker content.  SVG-only layout fields
+ * (`shape`, `size`) are omitted because they only affect SVG generation.
+ * Color/shadow options are retained — they are applied as CSS custom properties
+ * on the supplied element and can be consumed by its styles.
+ */
+export type MapTilerMarkerBehaviourOptions = Omit<MapTilerMarkerBaseOptions, "shape" | "size">;
+/** Options for a marker whose content is a pre-built DOM/SVG element. */
+export type MapTilerMarkerElementOptions = MapTilerMarkerBehaviourOptions & MarkerContentTypeElement;
+/** Options for a marker whose content is generated from the built-in SVG system. */
+export type MapTilerMarkerSVGOptions = MapTilerMarkerBaseOptions & Exclude<MarkerContent, MarkerContentTypeElement>;
+type MapTilerMarkerElementPropKeys = "shape" | "outerColor" | "innerColor" | "contentColor" | "outline" | "outlineColor" | "shadow" | "opacity" | "title" | "content" | "htmlAttributes" | "rotation" | "scale" | "size" | "debug" | "priority";
+export type MapTilerMarkerElementProps = Pick<MapTilerMarkerBaseOptions, MapTilerMarkerElementPropKeys>;
+export type MapTilerMarkerOptions = MapTilerMarkerBaseOptions & MarkerContent;
+/**
+ * Batch of property updates waiting to be flushed to the DOM.
+ * A key being present (even with an `undefined` value) means "apply this
+ * property" — e.g. `{ shadow: undefined }` resets the shadow to its default.
+ */
+export type PendingMarkerUpdates = Partial<MapTilerMarkerElementProps>;
+/** Options for `map.removeMarker()` and `map.removeMarkers()`. */
+export type RemoveMarkerOptions = {
+    /** Removes the markers straight away, without playing their `exit` animation. Defaults to `false`. */
+    immediate?: boolean;
+};
+/**
+ * Shape of an event fired by the SDK `Marker` on top of the MapLibre events,
+ * with the properties passed to `fire(type, properties)` merged in.
+ */
+type SDKMarkerEvent<TType extends string, TProps extends object = object> = EventML<TType> & {
+    target: Marker;
+} & TProps;
+type LifecycleAnimationEvent<TType extends MarkerLifecycleAnimationEventData["type"]> = SDKMarkerEvent<TType, Pick<MarkerLifecycleAnimationEventData, "preset">>;
+/**
+ * Events fired by the MapTiler SDK `Marker` in addition to the MapLibre ones.
+ */
+export type MaptilerMarkerEventType = {
+    markeroverlap: SDKMarkerEvent<"markeroverlap", MarkerCollisionEventData>;
+    markerproximity: SDKMarkerEvent<"markerproximity", MarkerCollisionEventData>;
+    transitionstart: SDKMarkerEvent<"transitionstart", Pick<MarkerTransitionEventData, "props">>;
+    transitionend: SDKMarkerEvent<"transitionend", Pick<MarkerTransitionEventData, "props">>;
+    enteranimationstart: LifecycleAnimationEvent<"enteranimationstart">;
+    enteranimationend: LifecycleAnimationEvent<"enteranimationend">;
+    exitanimationstart: LifecycleAnimationEvent<"exitanimationstart">;
+    exitanimationend: LifecycleAnimationEvent<"exitanimationend">;
+    idleanimationstart: LifecycleAnimationEvent<"idleanimationstart">;
+    idleanimationiteration: LifecycleAnimationEvent<"idleanimationiteration">;
+    idleanimationend: LifecycleAnimationEvent<"idleanimationend">;
+};
+/**
+ * All the events that can be listened to on a MapTiler SDK `Marker`: the MapLibre ones plus the SDK ones.
+ * MapLibre's `on`/`once`/`off` only accept the keys of `MarkerEventType`,
+ * so the SDK `Marker` overrides them to accept its own events as well.
+ */
+export type MarkerEventTypeSDK = MarkerEventType & MaptilerMarkerEventType;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export type * from 'maplibre-gl';
+export type { Marker as MLMarker } from 'maplibre-gl';
 /**
  * Get the version of MapTiler SDK, this is declared in the vite config
  * to avoid importing the entire package.json
@@ -6,8 +7,10 @@ export type * from 'maplibre-gl';
 export declare function getVersion(): string;
 export { setRTLTextPlugin, getRTLTextPluginStatus, LngLat, LngLatBounds, MercatorCoordinate, Evented, AJAXError, clearPrewarmedResources, Hash, Point, EdgeInsets, DragRotateHandler, DragPanHandler, TwoFingersTouchZoomRotateHandler, DoubleClickZoomHandler, TwoFingersTouchZoomHandler, TwoFingersTouchRotateHandler, getWorkerCount, setWorkerCount, getMaxParallelImageRequests, setMaxParallelImageRequests, getWorkerUrl, setWorkerUrl, addSourceType, importScriptInWorkers, addProtocol, removeProtocol, } from 'maplibre-gl';
 export { getVersion as getMapLibreVersion, Map as MapMLGL, Marker as MarkerMLGL, Popup as PopupMLGL, Style as StyleMLGL, CanvasSource as CanvasSourceMLGL, GeoJSONSource as GeoJSONSourceMLGL, ImageSource as ImageSourceMLGL, RasterTileSource as RasterTileSourceMLGL, RasterDEMTileSource as RasterDEMTileSourceMLGL, VectorTileSource as VectorTileSourceMLGL, VideoSource as VideoSourceMLGL, NavigationControl as NavigationControMLGL, GeolocateControl as GeolocateControlMLGL, AttributionControl as AttributionControlMLGL, LogoControl as LogoControlMLGL, ScaleControl as ScaleControlMLGL, FullscreenControl as FullscreenControlMLGL, TerrainControl as TerrainControMLGL, BoxZoomHandler as BoxZoomHandlerMLGL, ScrollZoomHandler as ScrollZoomHandlerMLGL, CooperativeGesturesHandler as CooperativeGesturesHandlerMLGL, KeyboardHandler as KeyboardHandlerMLGL, TwoFingersTouchPitchHandler as TwoFingersTouchPitchHandlerMLGL, MapWheelEvent as MapWheelEventMLGL, MapTouchEvent as MapTouchEventMLGL, MapMouseEvent as MapMouseEventMLGL, config as configMLGL, } from 'maplibre-gl';
-export { Marker, Popup, Style, CanvasSource, GeoJSONSource, ImageSource, RasterTileSource, RasterDEMTileSource, VectorTileSource, VideoSource, NavigationControl, GeolocateControl, AttributionControl, LogoControl, ScaleControl, FullscreenControl, TerrainControl, BoxZoomHandler, ScrollZoomHandler, CooperativeGesturesHandler, KeyboardHandler, TwoFingersTouchPitchHandler, MapWheelEvent, MapTouchEvent, MapMouseEvent, } from 'maplibre-gl';
-export { Map, GeolocationType, type AttributionControlOptions, type MapOptions, type LoadWithTerrainEvent, type MaptilerMapEventType, type MapEventTypeSDK } from './Map';
+export * from './Marker';
+export { Marker } from './Marker';
+export { Popup, Style, CanvasSource, GeoJSONSource, ImageSource, RasterTileSource, RasterDEMTileSource, VectorTileSource, VideoSource, NavigationControl, GeolocateControl, AttributionControl, LogoControl, ScaleControl, FullscreenControl, TerrainControl, BoxZoomHandler, ScrollZoomHandler, CooperativeGesturesHandler, KeyboardHandler, TwoFingersTouchPitchHandler, MapWheelEvent, MapTouchEvent, MapMouseEvent, } from 'maplibre-gl';
+export { Map, GeolocationType, type AttributionControlOptions, type MapOptions, type LoadWithTerrainEvent, type MaptilerMapEventType, type MapEventTypeSDK, type MapEventSDK, type MapLayerEventSDK, } from './Map';
 export type { CameraPosition, TilePreloadOptions, WithTilePreload, PreloadTilesForBoundsOptions, PreloadTilesForCameraPositionsOptions, PreloadTilesOptions, TilePreloadErrorCallback, TilePreloadProgressCallback, } from './tile-preloading';
 export { type BaseGeocodingOptions, type ByIdGeocodingOptions, type CommonForwardAndReverseGeocodingOptions, type GeocodingOptions, type LanguageGeocodingOptions, type ReverseGeocodingOptions, geocoding, } from './geocoding';
 export * from './controls';

package/dist/mapstyle.d.ts

@@ -16,4 +16,11 @@ type StyleValidationReport = {
     styleObject: StyleSpecification | null;
 };
 export declare function convertStringToStyleSpecification(str: string): StyleValidationReport;
+/**
+ * Derives the MapTiler style id (e.g. `"streets-v4-dark"`) from a style input,
+ * without expanding or fetching it.
+ * Returns `undefined` for custom `StyleSpecification`s and URLs that don't
+ * follow the MapTiler Cloud `/maps/<id>/style.json` shape.
+ */
+export declare function styleToStyleId(style: string | ReferenceMapStyle | MapStyleVariant | StyleSpecification | null | undefined): string | undefined;
 export {};