@maptiler/sdk 3.4.0-rc1 → 3.4.0-rc3

package/dist/src/language.d.ts

@@ -0,0 +1,107 @@
+import { LanguageInfo } from '@maptiler/client';
+declare const Language: {
+    readonly ALBANIAN: LanguageInfo;
+    readonly AMHARIC: LanguageInfo;
+    readonly ARABIC: LanguageInfo;
+    readonly ARMENIAN: LanguageInfo;
+    readonly AZERBAIJANI: LanguageInfo;
+    readonly BASQUE: LanguageInfo;
+    readonly BELARUSIAN: LanguageInfo;
+    readonly BENGALI: LanguageInfo;
+    readonly BOSNIAN: LanguageInfo;
+    readonly BRETON: LanguageInfo;
+    readonly BULGARIAN: LanguageInfo;
+    readonly CATALAN: LanguageInfo;
+    readonly CHINESE: LanguageInfo;
+    readonly TRADITIONAL_CHINESE: LanguageInfo;
+    readonly SIMPLIFIED_CHINESE: LanguageInfo;
+    readonly CORSICAN: LanguageInfo;
+    readonly CROATIAN: LanguageInfo;
+    readonly CZECH: LanguageInfo;
+    readonly DANISH: LanguageInfo;
+    readonly DUTCH: LanguageInfo;
+    readonly GERMAN: LanguageInfo;
+    readonly GREEK: LanguageInfo;
+    readonly ENGLISH: LanguageInfo;
+    readonly ESPERANTO: LanguageInfo;
+    readonly ESTONIAN: LanguageInfo;
+    readonly FINNISH: LanguageInfo;
+    readonly FRENCH: LanguageInfo;
+    readonly FRISIAN: LanguageInfo;
+    readonly GEORGIAN: LanguageInfo;
+    readonly HEBREW: LanguageInfo;
+    readonly HINDI: LanguageInfo;
+    readonly HUNGARIAN: LanguageInfo;
+    readonly ICELANDIC: LanguageInfo;
+    readonly INDONESIAN: LanguageInfo;
+    readonly IRISH: LanguageInfo;
+    readonly ITALIAN: LanguageInfo;
+    readonly JAPANESE: LanguageInfo;
+    readonly JAPANESE_HIRAGANA: LanguageInfo;
+    readonly JAPANESE_2018: LanguageInfo;
+    readonly JAPANESE_KANA: LanguageInfo;
+    readonly JAPANESE_LATIN: LanguageInfo;
+    readonly KANNADA: LanguageInfo;
+    readonly KAZAKH: LanguageInfo;
+    readonly KOREAN: LanguageInfo;
+    readonly KOREAN_LATIN: LanguageInfo;
+    readonly KURDISH: LanguageInfo;
+    readonly CLASSICAL_LATIN: LanguageInfo;
+    readonly LATVIAN: LanguageInfo;
+    readonly LITHUANIAN: LanguageInfo;
+    readonly LUXEMBOURGISH: LanguageInfo;
+    readonly MACEDONIAN: LanguageInfo;
+    readonly MALAYALAM: LanguageInfo;
+    readonly MALTESE: LanguageInfo;
+    readonly NORWEGIAN: LanguageInfo;
+    readonly OCCITAN: LanguageInfo;
+    readonly PERSIAN: LanguageInfo;
+    readonly POLISH: LanguageInfo;
+    readonly PORTUGUESE: LanguageInfo;
+    readonly PUNJABI: LanguageInfo;
+    readonly WESTERN_PUNJABI: LanguageInfo;
+    readonly ROMANIAN: LanguageInfo;
+    readonly ROMANSH: LanguageInfo;
+    readonly RUSSIAN: LanguageInfo;
+    readonly SERBIAN_CYRILLIC: LanguageInfo;
+    readonly SERBIAN_LATIN: LanguageInfo;
+    readonly SCOTTISH_GAELIC: LanguageInfo;
+    readonly SLOVAK: LanguageInfo;
+    readonly SLOVENE: LanguageInfo;
+    readonly SPANISH: LanguageInfo;
+    readonly SWEDISH: LanguageInfo;
+    readonly TAMIL: LanguageInfo;
+    readonly TELUGU: LanguageInfo;
+    readonly THAI: LanguageInfo;
+    readonly TURKISH: LanguageInfo;
+    readonly UKRAINIAN: LanguageInfo;
+    readonly VIETNAMESE: LanguageInfo;
+    readonly WELSH: LanguageInfo;
+    readonly AUTO: LanguageInfo;
+    readonly LATIN: LanguageInfo;
+    readonly NON_LATIN: LanguageInfo;
+    readonly LOCAL: LanguageInfo;
+    /**
+     * Language mode to display labels in both the local language and the language of the visitor's device, concatenated.
+     * Note that if those two languages are the same, labels won't be duplicated.
+     */
+    readonly VISITOR: LanguageInfo;
+    /**
+     * Language mode to display labels in both the local language and English, concatenated.
+     * Note that if those two languages are the same, labels won't be duplicated.
+     */
+    readonly VISITOR_ENGLISH: LanguageInfo;
+    /**
+     * Language mode to display labels in a language enforced in the style.
+     */
+    readonly STYLE: LanguageInfo;
+    /**
+     * Language mode to display labels in a language enforced in the style. The language cannot be further modified.
+     */
+    readonly STYLE_LOCK: LanguageInfo;
+};
+/**
+ * Get the browser language
+ */
+export declare function getBrowserLanguage(): LanguageInfo;
+export { Language, type LanguageInfo };

package/dist/src/mapstyle.d.ts

@@ -0,0 +1,17 @@
+import { ReferenceMapStyle, MapStyleVariant } from '@maptiler/client';
+export declare function styleToStyle(style: string | ReferenceMapStyle | MapStyleVariant | maplibregl.StyleSpecification | null | undefined): {
+    style: string | maplibregl.StyleSpecification;
+    requiresUrlMonitoring: boolean;
+    isFallback: boolean;
+};
+/**
+ * makes sure a URL is absolute
+ */
+export declare function urlToAbsoluteUrl(url: string): string;
+type StyleValidationReport = {
+    isValidJSON: boolean;
+    isValidStyle: boolean;
+    styleObject: maplibregl.StyleSpecification | null;
+};
+export declare function convertToStyleSpecificationString(str: string): StyleValidationReport;
+export {};

package/dist/src/tools.d.ts

@@ -0,0 +1,84 @@
+import { default as maplibregl, RequestParameters, ResourceType, RequestTransformFunction } from 'maplibre-gl';
+import { Map as MapSDK } from './Map';
+export declare function enableRTL(): void;
+export declare function bindAll(fns: Array<string>, context: any): void;
+/**
+ * This function is meant to be used as transformRequest by any Map instance created.
+ * It adds the session ID as well as the MapTiler Cloud key from the config to all the requests
+ * performed on MapTiler Cloud servers.
+ */
+export declare function maptilerCloudTransformRequest(url: string, resourceType?: ResourceType): RequestParameters;
+/**
+ * This combines a user-defined tranformRequest function (optionnal)
+ * with the MapTiler Cloud-specific one: maptilerCloudTransformRequest
+ */
+export declare function combineTransformRequest(userDefinedRTF?: RequestTransformFunction | null): RequestTransformFunction;
+/**
+ * Generate a random string. Handy to create random IDs
+ */
+export declare function generateRandomString(): string;
+/**
+ * Check if a given string is in a uuid format
+ */
+export declare function isUUID(s: string): boolean;
+/**
+ * Attempt a JSON parse of a string but does not throw if the string is not valid JSON, returns `null` instead.
+ */
+export declare function jsonParseNoThrow<T>(doc: string): T | null;
+/**
+ * Simple function to check if an object is a GeoJSON
+ */
+export declare function isValidGeoJSON<T>(obj: T & {
+    type: string;
+}): boolean;
+/**
+ * This function tests if WebGL2 is supported. Since it can be for a different reasons that WebGL2 is
+ * not supported but we do not have an action to take based on the reason, this function return null
+ * if there is no error (WebGL is supported), or returns a string with the error message if WebGL2 is
+ * not supported.
+ */
+export declare function getWebGLSupportError(): string | null;
+/**
+ * Display an error message in the Map div if WebGL2 is not supported
+ */
+export declare function displayNoWebGlWarning(container: HTMLElement | string): void;
+/**
+ * Display a warning message in the Map div if the WebGL context was lost
+ */
+export declare function displayWebGLContextLostWarning(map: MapSDK): void;
+/**
+ * In a text-field style property (as an object, not a string) the languages that are specified as
+ * ["get", "name:XX"] are replaced by the proved replacer (also an object).
+ * This replacement happened regardless of how deep in the object the flag is.
+ * Note that it does not replace the occurences of ["get", "name"] (local names)
+ */
+export declare function changeFirstLanguage(origExpr: maplibregl.ExpressionSpecification, replacer: maplibregl.ExpressionSpecification, localized: boolean): maplibregl.ExpressionSpecification;
+/**
+ * If `localized` is `true`, it checks for the pattern "{name:xx}" (with "xx" being a language iso string).
+ * If `localized` is `false`, it check for {name}.
+ * In a exact way or is a loose way (such as "foo {name:xx}" or "foo {name} bar")
+ */
+export declare function checkNamePattern(str: string, localized: boolean): {
+    contains: boolean;
+    exactMatch: boolean;
+};
+/**
+ * Replaces the occurences of {name:xx} in a string by a provided object-expression to return a concat object expression
+ */
+export declare function replaceLanguage(origLang: string, newLang: maplibregl.ExpressionSpecification, localized: boolean): maplibregl.ExpressionSpecification;
+/**
+ * Find languages used in string label definition.
+ * The returned array contains languages such as "en", "fr" but
+ * can also contain null that stand for the use of {name}
+ */
+export declare function findLanguageStr(str: string): Array<string | null>;
+/**
+ * Find languages used in object label definition.
+ * The returned array contains languages such as "en", "fr" but
+ * can also contain null that stand for the use of {name}
+ */
+export declare function findLanguageObj(origExpr: maplibregl.ExpressionSpecification): Array<string | null>;
+export declare function computeLabelsLocalizationMetrics(layers: maplibregl.LayerSpecification[], map: MapSDK): {
+    unlocalized: number;
+    localized: Record<string, number>;
+};

package/dist/src/types.d.ts

@@ -0,0 +1 @@
+export type Unit = "imperial" | "metric" | "nautical";

package/dist/src/utils/MaptilerAnimation/AnimationManager.d.ts

@@ -0,0 +1,41 @@
+import { default as MaptilerAnimation } from './MaptilerAnimation';
+/**
+ * Manager for handling animation lifecycle and updates.
+ *
+ * The AnimationManager provides a centralized system for registering and
+ * coordinating multiple animations. To avoid individual calls to request animation frame
+ * for each animation, it maintains an animation loop
+ *
+ * This is not a class as it never needs to be instantiated,
+ * it's just a singeton object.
+ *
+ * It's not called directly but used within the MaptilerAnimation class.
+ */
+declare const AnimationManager: {
+    animations: MaptilerAnimation[];
+    running: boolean;
+    /**
+     * Adds an animation to the manager. If this is the first animation added,
+     * it starts the animation loop.
+     *
+     * @param {MaptilerAnimation} animation - The animation to add.
+     */
+    add(animation: MaptilerAnimation): void;
+    /**
+     * Removes an animation from the manager. If there are no more animations,
+     * it stops the animation loop.
+     *
+     * @param {MaptilerAnimation} animation - The animation to remove.
+     */
+    remove(animation: MaptilerAnimation): void;
+    /**
+     * Stops the animation loop.
+     */
+    stop(): void;
+    /**
+     * Starts the animation loop. This function is called recursively using
+     * requestAnimationFrame to ensure smooth updates.
+     */
+    start(): void;
+};
+export default AnimationManager;

package/dist/src/utils/MaptilerAnimation/MaptilerAnimation.d.ts

@@ -0,0 +1,238 @@
+import { AnimationEventCallback, AnimationEventTypes, EasingFunctionName, Keyframe } from './types';
+/**
+ * Configuration options for creating an animation.
+ *
+ * @interface MaptilerAnimationOptions
+ * @property {Keyframe[]} keyframes - The keyframes that define the animation states at various points in time.
+ * @property {number} duration - The total duration of the animation in milliseconds.
+ * @property {number} iterations - The number of times the animation should repeat. Use 0 for no repeat, or Infinity for an infinite loop.
+ * @property {delay} [delay] - Optional. The delay before the animation starts, in milliseconds. Defaults to 0 if not specified.
+ * @property {boolean} [manualMode] - Optional. If true, the animation will not be automatically managed by the animation manager
+ *                                   and must be updated manually by calling update(). Defaults to false if not specified.
+ */
+export interface MaptilerAnimationOptions {
+    keyframes: Keyframe[];
+    duration: number;
+    iterations: number;
+    manualMode?: boolean;
+    delay?: number;
+}
+/**
+ * A keyframe in the animation sequence where null or undefined values
+ * are interpolated to fill in the gaps between keyframes.
+ *
+ * @extends Keyframe
+ * @property {Record<string, number>} props - The properties to be animated at this keyframe.
+ * @property {EasingFunctionName} easing - The easing function to use for this keyframe.
+ * @property {string} id - A unique identifier for this keyframe.
+ */
+export type InterpolatedKeyFrame = Keyframe & {
+    props: Record<string, number>;
+    easing: EasingFunctionName;
+    id: string;
+};
+/**
+ * Animation controller for keyframe-based animation sequences.
+ *
+ * MaptilerAnimation handles interpolation between keyframes, timing control,
+ * and event dispatching during animation playback.
+ *
+ * @example
+ * ```typescript
+ * const animation = new MaptilerAnimation({
+ *   keyframes: [
+ *     { delta: 0, props: { x: 0, y: 0 } },
+ *     { delta: 0.5, props: { x: 50, y: 20 } },
+ *     { delta: 1, props: { x: 100, y: 0 } }
+ *   ],
+ *   duration: 1000, // milliseconds
+ *   iterations: 2
+ * });
+ *
+ * animation.addEventListener(AnimationEventTypes.TimeUpdate, (event) => {
+ *   // Use interpolated property values to update something
+ *   console.log(event.props);
+ * });
+ *
+ * animation.play();
+ * ```
+ *
+ * @remarks
+ * The animation supports various playback controls (play, pause, stop, reset),
+ * time manipulation, and an event system for tracking animation progress.
+ * Properties missing in keyframes will be automatically interpolated.
+ *
+ * Animation events include play, pause, stop, timeupdate, iteration, and more.
+ *
+ * When not using manualMode, animations are automatically added to the AnimationManager.
+ */
+export default class MaptilerAnimation {
+    private playing;
+    /**
+     * Indicates if the animation is currently playing
+     * @returns {boolean} - true if the animation is playing, false otherwise
+     */
+    get isPlaying(): boolean;
+    /**
+     * The number of times to repeat the animation
+     * 0 is no repeat, Infinity is infinite repeat
+     */
+    private iterations;
+    private currentIteration;
+    /** An array of keyframes animations to interpolate between */
+    private keyframes;
+    /** The current keyframe id */
+    private currentKeyframe?;
+    /**The duration of the animation in milliseconds (when playbackRate === 1) */
+    readonly duration: number;
+    /**
+     * The duration of the animation affected by the playback rate
+     * if playback rate is 2, the effective duration is double
+     */
+    private effectiveDuration;
+    /** the rate at which the animation is playing */
+    private playbackRate;
+    /** the current time in milliseconds */
+    private currentTime;
+    /** 0 start of the animation, 1 end of the animation */
+    private currentDelta;
+    /** The time at which the animation started */
+    private animationStartTime;
+    /** The time at which the last frame was rendered */
+    private lastFrameAt;
+    /** The delay before the animation starts */
+    private delay;
+    /** The timeout ID for the delay before the animation starts */
+    private delayTimeoutID?;
+    /** The listeners added for each event */
+    private listeners;
+    /** The props from the previous frame */
+    private previousProps;
+    constructor({ keyframes, duration, iterations, manualMode, delay }: MaptilerAnimationOptions);
+    /**
+     * Starts or resumes the animation
+     * @returns This animation instance for method chaining
+     * @event AnimationEventTypes.Play
+     */
+    play(): this;
+    /**
+     * Pauses the animation
+     * @returns This animation instance for method chaining
+     * @event AnimationEventTypes.Pause
+     */
+    pause(): this;
+    /**
+     * Stops the animation and resets to initial state
+     * @returns This animation instance for method chaining
+     * @event AnimationEventTypes.Stop
+     */
+    stop(silent?: boolean): this;
+    /**
+     * Resets the animation to its initial state without stopping
+     * @returns This animation instance for method chaining
+     * @event AnimationEventTypes.Reset
+     */
+    reset(manual?: boolean): this;
+    /**
+     * Updates the animation state if playing, this is used by the AnimationManager
+     * to update all animations in the loop
+     * @returns This animation instance for method chaining
+     */
+    updateInternal(): this;
+    /**
+     * Updates the animation state, interpolating between keyframes
+     * and emitting events as necessary
+     * @event AnimationEventTypes.TimeUpdate
+     * @event AnimationEventTypes.Keyframe
+     * @event AnimationEventTypes.Iteration
+     * @event AnimationEventTypes.AnimationEnd
+     * @returns This animation instance for method chaining
+     */
+    update(manual?: boolean, ignoreIteration?: boolean): this;
+    /**
+     * Gets the current and next keyframes at a specific time
+     * @param time - The time position to query
+     * @returns Object containing current and next keyframes, which may be null
+     */
+    getCurrentAndNextKeyFramesAtTime(time: number): {
+        current: InterpolatedKeyFrame | null;
+        next: InterpolatedKeyFrame | null;
+    };
+    /**
+     * Gets the current and next keyframes at a specific delta value
+     * @param delta - The delta value to query
+     * @returns Object containing current and next keyframes, which may be null
+     */
+    getCurrentAndNextKeyFramesAtDelta(delta: number): {
+        current: InterpolatedKeyFrame | null;
+        next: InterpolatedKeyFrame | null;
+    };
+    /**
+     * Gets the current time position of the animation
+     * @returns The current time in milliseconds
+     */
+    getCurrentTime(): number;
+    /**
+     * Sets the current time position of the animation
+     * @param time - The time to set in milliseconds
+     * @returns This animation instance for method chaining
+     * @throws Error if time is greater than the duration
+     * @event AnimationEventTypes.Scrub
+     */
+    setCurrentTime(time: number): this;
+    /**
+     * Gets the current delta value of the animation
+     * @returns The current delta value (normalized progress between 0 and 1)
+     */
+    getCurrentDelta(): number;
+    /**
+     * Sets the current delta value of the animation
+     * @param delta - The delta value to set (normalized progress between 0 and 1)
+     * @returns This animation instance for method chaining
+     * @throws Error if delta is greater than 1
+     * @event AnimationEventTypes.Scrub
+     */
+    setCurrentDelta(delta: number): this;
+    /**
+     * Sets the playback rate of the animation
+     * @param rate - The playback rate (1.0 is normal speed)
+     * @returns This animation instance for method chaining
+     * @event AnimationEventTypes.PlaybackRateChange
+     */
+    setPlaybackRate(rate: number): this;
+    /**
+     * Gets the current playback rate
+     * @returns The current playback rate
+     */
+    getPlaybackRate(): number;
+    /**
+     * Adds an event listener to the animation
+     * @param type - The type of event to listen for
+     * @param callback - The callback function to execute when the event occurs
+     * @returns This animation instance for method chaining
+     */
+    addEventListener(type: AnimationEventTypes, callback: AnimationEventCallback): this;
+    /**
+     * Removes an event listener from the animation
+     * @param type - The type of event to remove
+     * @param callback - The callback function to remove
+     * @returns This animation instance for method chaining
+     */
+    removeEventListener(type: AnimationEventTypes, callback: AnimationEventCallback): this;
+    /**
+     * Emits an event to all listeners of a specific type
+     * @param event - The type of event to emit
+     * @param keyframe - The keyframe that triggered the event
+     * @param props - The interpolated properties at the current delta
+     */
+    emitEvent(event: AnimationEventTypes, keyframe?: Keyframe | null, nextKeyframe?: Keyframe | null, props?: Record<string, number>, previousProps?: Record<string, number>): void;
+    /**
+     * Creates a clone of this animation
+     * @returns A new animation instance with the same properties as this one
+     */
+    clone(): MaptilerAnimation;
+    /**
+     * Destroys the animation instance, removing all event listeners and stopping playback
+     */
+    destroy(): void;
+}

package/dist/src/utils/MaptilerAnimation/animation-helpers.d.ts

@@ -0,0 +1,182 @@
+import { Feature, LineString, MultiLineString, MultiPoint, Polygon } from 'geojson';
+import { EasingFunctionName, Keyframe, NumericArrayWithNull } from './types';
+/**
+ * Performs simple linear interpolation between two numbers.
+ *
+ * @param a - The start value
+ * @param b - The end value
+ * @param alpha - The interpolation factor (typically between 0 and 1):
+ *                0 returns a, 1 returns b, and values in between return a proportional mix
+ * @returns The interpolated value between a and b
+ */
+export declare function lerp(a: number, b: number, alpha: number): number;
+/**
+ * Interpolates an array of numbers, replacing null values with interpolated values.
+ *
+ * `null` is treated as an empty value where an interpolation is needed.
+ *
+ * @param {NumericArrayWithNull} numericArray - The array of numbers to interpolate, which may contain null values
+ * @returns A new array with null values replaced by interpolated values
+ */
+export declare function lerpArrayValues(numericArray: NumericArrayWithNull): number[];
+/**
+ * Looks ahead in an array for the next entry that is not null.
+ *
+ * @param arr - The array to search through
+ * @param currentIndex - The index to start searching from
+ * @returns [index, value] A tuple containing the index of the next entry and its value, or null if not found
+ */
+export declare function findNextEntryAndIndexWithValue(arr: NumericArrayWithNull, currentIndex: number): (number | null)[];
+/**
+ * Looks back in an array for the previous entry that is not null.
+ *
+ * @param arr - The array to search through
+ * @param currentIndex - The index to start searching from
+ * @returns [index, value] A tuple containing the index of the previous entry and its value, or null if not found
+ */
+export declare function findPreviousEntryAndIndexWithValue(arr: NumericArrayWithNull, currentIndex: number): (number | null)[];
+/**
+ * Options for parsing GeoJSON data into animation keyframes.
+ *
+ * @interface IparseGeoJSONToKeyframesOptions
+ * @property {EasingFunctionName} [defaultEasing] - The default easing function to apply to the animation.
+ * @property {Object|false} [pathSmoothing] - Configuration for path smoothing, or false to disable smoothing.
+ * @property {number} [pathSmoothing.resolution] - The resolution used for path smoothing, higher values produce more detailed paths.
+ * @property {number} [pathSmoothing.epsilon] - Optional tolerance parameter for path simplification.
+ */
+export interface IparseGeoJSONToKeyframesOptions {
+    defaultEasing?: EasingFunctionName;
+    pathSmoothing?: {
+        resolution: number;
+        epsilon?: number;
+    } | false;
+}
+/**
+ * Represents geometry types that can be animated using keyframes.
+ *
+ * This type includes geometries like MultiPoint, LineString, MultiLineString, and Polygon
+ * which can be interpolated or transformed over time in animations.
+ */
+export type KeyframeableGeometry = MultiPoint | LineString | MultiLineString | Polygon;
+/**
+ * Represents a GeoJSON Feature that can be animated with keyframes.
+ * Extends the standard GeoJSON Feature with animation-specific properties.
+ *
+ * @typedef {Object} KeyframeableGeoJSONFeature
+ * @extends {Feature<KeyframeableGeometry>}
+ * @property {Object} properties - Contains both standard GeoJSON properties (as number arrays) and animation controls
+ * @property {EasingFunctionName[]} [properties.@easing] - Easing functions to apply to property animations
+ * @property {number[]} [properties.@delta] - Delta values for animation calculations
+ * @property {number} [properties.@duration] - Duration of the animation in milliseconds
+ * @property {number} [properties.@delay] - Delay before animation starts in milliseconds
+ * @property {number} [properties.@iterations] - Number of times the animation should repeat
+ * @property {boolean} [properties.@autoplay] - Whether the animation should start automatically
+ */
+export type KeyframeableGeoJSONFeature = Feature<KeyframeableGeometry> & {
+    properties: Record<string, number[]> & {
+        "@easing"?: EasingFunctionName[];
+        "@delta"?: number[];
+        "@duration"?: number;
+        "@delay"?: number;
+        "@iterations"?: number;
+        "@autoplay"?: boolean;
+        altitude?: (number | null)[];
+    };
+};
+/**
+ * Converts a GeoJSON feature into an array of animation keyframes.
+ *
+ * Parses a GeoJSON feature with reserved properties to create animation keyframes.
+ * It extracts coordinates from the geometry and uses properties prefixed with '@' as animation
+ * control parameters (easing functions, delta values). Non-reserved properties are preserved
+ * and passed to the keyframe objects as props that will be interpolated
+ *
+ * @param {KeyframeableGeoJSONFeature} feature - The GeoJSON feature to convert to keyframes
+ * @param {IparseGeoJSONToKeyframesOptions} options - Configuration options
+ *
+ * @returns Array of keyframe objects that can be used for animation
+ *
+ * @throws {Error} When no geometry is found in the feature
+ * @throws {Error} When the geometry type is not supported
+ */
+export declare function parseGeoJSONFeatureToKeyframes(feature: KeyframeableGeoJSONFeature, options?: IparseGeoJSONToKeyframesOptions): Keyframe[];
+/**
+ *
+ * "Stretches" an array of numbers to a new length, filling in null values for the new indices.
+ *
+ * @param source the array to stretch
+ * @param targetLength the length to stretch to
+ * @returns {number[]} the stretched array with null values
+ */
+export declare function stretchNumericalArray(source: number[], targetLength: number): (number | null)[];
+/**
+ * Generates an array of keyframes from coordinates, deltas, easings, and other properties provided by the geoJSON feature.
+ * Assumes that the coordinates are in the format [longitude, latitude, altitude?]. If altitude is not provided, it defaults to 0.
+ *
+ * @param coordinates - Array of coordinate points, where each point is an array of [longitude, latitude, altitude?]
+ * @param deltas - Array of time deltas between keyframes
+ * @param easings - Array of easing function names to apply to each keyframe transition
+ * @param properties - Optional additional properties as key-value pairs, where each value is an array
+ * of numbers corresponding to each keyframe
+ *
+ * @returns An array of Keyframe objects, each containing coordinate props, delta, and easing information
+ *
+ * @throws Error if the arrays for coordinates, deltas, easings, and any property values don't have matching lengths
+ *
+ * @example
+ * const keyframes = getKeyframes(
+ *   [[0, 0, 10], [10, 10, 20]], // coordinates
+ *   [1000, 2000], // deltas (in milliseconds)
+ *   [EasingFunctionName.Linear, EasingFunctionName.ElasticIn], // easings
+ *   { zoom: [10, 15] } // additional properties
+ * );
+ */
+export declare function getKeyframes(coordinates: number[][], deltas: number[], easings: EasingFunctionName[], properties?: Record<string, number[]>): Keyframe[];
+/**
+ * Creates a smoothed path using cubic Bezier curves from an array of coordinates.
+ *
+ * This function takes a series of points and creates a smooth path by generating cubic
+ * Bezier curves between them. It uses the Catmull-Rom method to automatically calculate
+ * control points for each curve segment. If the path has fewer than 4 points, the original
+ * path is returned unchanged.
+ *
+ * @param inputPath - Array of [x, y] coordinates that define the original path
+ * @param outputResolution - Controls how many points are generated along each segment
+ *                           (higher values create smoother curves with more points)
+ * @param simplificationThreshold - Optional threshold for simplifying the input path before
+ *                                  creating the curves.
+ * @returns An array of [x, y] coordinates representing the smoothed path
+ */
+export declare function createBezierPathFromCoordinates(inputPath: [number, number][], outputResolution?: number, simplificationThreshold?: number): [number, number][];
+/**
+ * Calculates the average distance between points in an array of coordinates.
+ *
+ * This function computes the average distance between consecutive points in the array.
+ * It uses the LngLat class from MapLibre to calculate distances based on geographical coordinates.
+ *
+ * @param arr - An array of coordinate pairs [longitude, latitude]
+ * @returns The average distance between points in the array
+ */
+export declare function getAverageDistance(arr: [number, number][]): number;
+/**
+ * Simplfies a path by removing points that are too close together.
+ *
+ * This function first resamples the path based on the average distance between points,
+ * then filters out points that are closer than the specified distance from the last included point.
+ * The first and last points of the original path are always preserved.
+ *
+ * @param points - An array of coordinate pairs [longitude, latitude]
+ * @param distance - The minimum distance between points in the simplified path
+ * @returns A new array containing a simplified version of the input path
+ */
+export declare function simplifyPath(points: [number, number][], distance: number): [number, number][];
+/**
+ * Resamples a geographic path to have points spaced at approximately equal distances.
+ * If the original path has fewer than 2 points, it is returned unchanged.
+ *
+ * @param path - An array of coordinate pairs [longitude, latitude] representing the path to resample
+ * @param spacing - The desired spacing between points in the resampled path (in the same unit as used by the distanceTo method), defaults to 10
+ * @returns A new array of coordinate pairs representing the resampled path with approximately equal spacing between points
+ *
+ */
+export declare function resamplePath(path: [number, number][], spacing?: number): [number, number][];

package/dist/src/utils/MaptilerAnimation/easing.d.ts

@@ -0,0 +1,3 @@
+import { EasingFunctionName } from './types';
+declare const EasingFunctions: Record<EasingFunctionName, (K: number) => number>;
+export default EasingFunctions;