@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.2

package/lib/typescript/commonjs/src/utils/animated/AbstractAnimatedCoordinates.d.ts

@@ -0,0 +1,37 @@
+import { Animated } from "react-native";
+declare const AnimatedWithChildren: any;
+export type AnimatedCoordinates = [number, number];
+declare abstract class AbstractAnimatedCoordinates<State> extends AnimatedWithChildren {
+    static [x: string]: any;
+    constructor(coords: AnimatedCoordinates[]);
+    /**
+     * Subclasses can override to calculate initial state
+     *
+     * @param {AnimatedCoordinates} coordinatesArray - to value from animate
+     * @returns {object} - the state object
+     */
+    abstract onInitialState(coords: AnimatedCoordinates[]): State;
+    /**
+     * Calculates state based on startingState and progress, returns a new state
+     *
+     * @param {object} state - state object from initialState and/or from calculate
+     * @param {number} progress - value between 0 and 1
+     * @returns {object} next state
+     */
+    abstract onCalculate(state: State, progress: number): State;
+    animate(progressValue: Animated.Value, progressAnimation: Animated.CompositeAnimation, config: (Animated.TimingAnimationConfig | Animated.SpringAnimationConfig | Animated.DecayAnimationConfig) & {
+        toValue: AnimatedCoordinates[];
+    }): Animated.CompositeAnimation;
+    timing(config: Animated.TimingAnimationConfig & {
+        toValue: AnimatedCoordinates[];
+    }): Animated.CompositeAnimation;
+    spring(config: Animated.SpringAnimationConfig & {
+        toValue: AnimatedCoordinates[];
+    }): Animated.CompositeAnimation;
+    decay(config: Animated.DecayAnimationConfig & {
+        toValue: AnimatedCoordinates[];
+    }): Animated.CompositeAnimation;
+    __getValue(): AnimatedCoordinates[];
+}
+export default AbstractAnimatedCoordinates;
+//# sourceMappingURL=AbstractAnimatedCoordinates.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/AbstractAnimatedCoordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractAnimatedCoordinates.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/AbstractAnimatedCoordinates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAIxC,QAAA,MAAM,oBAAoB,KAA0C,CAAC;AASrE,MAAM,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAMnD,uBAAe,2BAA2B,CAAC,KAAK,CAAE,SAAQ,oBAAoB;;gBAChE,MAAM,EAAE,mBAAmB,EAAE;IAMzC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,MAAM,EAAE,mBAAmB,EAAE,GAAG,KAAK;IAC7D;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK;IAE3D,OAAO,CACL,aAAa,EAAE,QAAQ,CAAC,KAAK,EAC7B,iBAAiB,EAAE,QAAQ,CAAC,kBAAkB,EAC9C,MAAM,EAAE,CACJ,QAAQ,CAAC,qBAAqB,GAC9B,QAAQ,CAAC,qBAAqB,GAC9B,QAAQ,CAAC,oBAAoB,CAChC,GAAG;QAAE,OAAO,EAAE,mBAAmB,EAAE,CAAA;KAAE,GACrC,QAAQ,CAAC,kBAAkB;IA2B9B,MAAM,CACJ,MAAM,EAAE,QAAQ,CAAC,qBAAqB,GAAG;QACvC,OAAO,EAAE,mBAAmB,EAAE,CAAC;KAChC,GACA,QAAQ,CAAC,kBAAkB;IAa9B,MAAM,CACJ,MAAM,EAAE,QAAQ,CAAC,qBAAqB,GAAG;QAAE,OAAO,EAAE,mBAAmB,EAAE,CAAA;KAAE,GAC1E,QAAQ,CAAC,kBAAkB;IAa9B,KAAK,CACH,MAAM,EAAE,QAAQ,CAAC,oBAAoB,GAAG;QAAE,OAAO,EAAE,mBAAmB,EAAE,CAAA;KAAE,GACzE,QAAQ,CAAC,kBAAkB;IAY9B,UAAU,IAAI,mBAAmB,EAAE;CAQpC;AAED,eAAe,2BAA2B,CAAC"}

package/lib/typescript/commonjs/src/utils/animated/Animated.d.ts

@@ -0,0 +1,33 @@
+import React from "react";
+import { Animated as RNAnimated } from "react-native";
+import AnimatedCoordinatesArray from "./AnimatedCoordinatesArray";
+import AnimatedExtractCoordinateFromArray from "./AnimatedExtractCoordinateFromArray";
+import AnimatedRouteCoordinatesArray from "./AnimatedRouteCoordinatesArray";
+import AnimatedShape from "./AnimatedShape";
+import { type ShapeSourceProps, type ShapeSourceRef } from "../../components/ShapeSource";
+declare const Animated: {
+    ShapeSource: RNAnimated.AnimatedComponent<React.MemoExoticComponent<React.ForwardRefExoticComponent<ShapeSourceProps & React.RefAttributes<ShapeSourceRef>>>>;
+    ImageSource: RNAnimated.AnimatedComponent<React.FC<import("../../components/ImageSource").ImageSourceProps>>;
+    FillLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/FillLayer").FillLayerProps>>;
+    FillExtrusionLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/FillExtrusionLayer").FillExtrusionLayerProps>>;
+    LineLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/LineLayer").LineLayerProps>>;
+    CircleLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/CircleLayer").CircleLayerProps>>;
+    SymbolLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/SymbolLayer").SymbolLayerProps>>;
+    RasterLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/RasterLayer").RasterLayerProps>>;
+    BackgroundLayer: RNAnimated.AnimatedComponent<React.FC<import("../../components/BackgroundLayer").BackgroundLayerProps>>;
+    CoordinatesArray: typeof AnimatedCoordinatesArray;
+    RouteCoordinatesArray: typeof AnimatedRouteCoordinatesArray;
+    Shape: typeof AnimatedShape;
+    ExtractCoordinateFromArray: typeof AnimatedExtractCoordinateFromArray;
+};
+type ShapeSourcePropsWithRef = ShapeSourceProps & React.RefAttributes<ShapeSourceRef>;
+type BaseShapeSourceComponent = React.ForwardRefExoticComponent<ShapeSourcePropsWithRef>;
+type AnimatedShapeSourceType = RNAnimated.AnimatedComponent<BaseShapeSourceComponent> & React.MemoExoticComponent<BaseShapeSourceComponent>;
+/**
+ * Manual typing is required for AnimatedShapeSource because the
+ * following error:
+ * `Type instantiation is excessively deep and possibly infinite.ts(2589)`
+ */
+export declare const AnimatedShapeSource: AnimatedShapeSourceType;
+export default Animated;
+//# sourceMappingURL=Animated.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/Animated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Animated.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/Animated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAClE,OAAO,kCAAkC,MAAM,sCAAsC,CAAC;AACtF,OAAO,6BAA6B,MAAM,iCAAiC,CAAC;AAC5E,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAQ5C,OAAoB,EAClB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,8BAA8B,CAAC;AAGtC,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;CAmBb,CAAC;AAEF,KAAK,uBAAuB,GAAG,gBAAgB,GAC7C,KAAK,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;AAEtC,KAAK,wBAAwB,GAC3B,KAAK,CAAC,yBAAyB,CAAC,uBAAuB,CAAC,CAAC;AAE3D,KAAK,uBAAuB,GAC1B,UAAU,CAAC,iBAAiB,CAAC,wBAAwB,CAAC,GACpD,KAAK,CAAC,mBAAmB,CAAC,wBAAwB,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAE3B,uBAAuB,CAAC;AAE7B,eAAe,QAAQ,CAAC"}

package/lib/typescript/commonjs/src/utils/animated/AnimatedCoordinatesArray.d.ts

@@ -0,0 +1,40 @@
+import AbstractAnimatedCoordinates, { type AnimatedCoordinates } from "./AbstractAnimatedCoordinates";
+interface CoordinatesState {
+    coords: AnimatedCoordinates[];
+    targetCoords: AnimatedCoordinates[];
+}
+declare class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesState> {
+    /**
+     * Subclasses can override to calculate initial state
+     *
+     * @param {AnimatedCoordinates} coordinatesArray - to value from animate
+     * @returns {object} - the state object
+     */
+    onInitialState(coordinatesArray: AnimatedCoordinates[]): CoordinatesState;
+    /**
+     * Subclasses can override getValue to calculate value from state.
+     * Value is typically coordinates array, but can be anything
+     *
+     * @param {object} state - either state from initialState and/or from calculate
+     * @returns {object}
+     */
+    onGetValue(state: CoordinatesState): CoordinatesState["coords"];
+    /**
+     * Calculates state based on startingState and progress, returns a new state
+     *
+     * @param {object} state - state object from initialState and/or from calculate
+     * @param {number} progress - value between 0 and 1
+     * @returns {object} next state
+     */
+    onCalculate(state: CoordinatesState, progress: number): CoordinatesState;
+    /**
+     * Subclasses can override to start a new animation
+     *
+     * @param {*} state - to value from animate
+     * @param {*} toValue - the current coordinates array to start from
+     * @returns {object} The state
+     */
+    onStart(state: CoordinatesState, toValue: AnimatedCoordinates[]): CoordinatesState;
+}
+export default AnimatedCoordinatesArray;
+//# sourceMappingURL=AnimatedCoordinatesArray.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/AnimatedCoordinatesArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedCoordinatesArray.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/AnimatedCoordinatesArray.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,EAAE,EAClC,KAAK,mBAAmB,EACzB,MAAM,+BAA+B,CAAC;AAEvC,UAAU,gBAAgB;IACxB,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,YAAY,EAAE,mBAAmB,EAAE,CAAC;CACrC;AAED,cAAM,wBAAyB,SAAQ,2BAA2B,CAAC,gBAAgB,CAAC;IAClF;;;;;OAKG;IACH,cAAc,CAAC,gBAAgB,EAAE,mBAAmB,EAAE,GAAG,gBAAgB;IAUzE;;;;;;OAMG;IACH,UAAU,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAAC,QAAQ,CAAC;IAI/D;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB;IA+CxE;;;;;;OAMG;IACH,OAAO,CACL,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,mBAAmB,EAAE,GAC7B,gBAAgB;CASpB;AAED,eAAe,wBAAwB,CAAC"}

package/lib/typescript/commonjs/src/utils/animated/AnimatedExtractCoordinateFromArray.d.ts

@@ -0,0 +1,12 @@
+declare const AnimatedWithChildren: any;
+export default class AnimatedExtractCoordinateFromArray extends AnimatedWithChildren {
+    static [x: string]: any;
+    _array: AnimatedExtractCoordinateFromArray;
+    _index: number;
+    constructor(array: AnimatedExtractCoordinateFromArray, index: number);
+    __getValue(): AnimatedExtractCoordinateFromArray;
+    __attach(): void;
+    __detach(): void;
+}
+export {};
+//# sourceMappingURL=AnimatedExtractCoordinateFromArray.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/AnimatedExtractCoordinateFromArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedExtractCoordinateFromArray.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/AnimatedExtractCoordinateFromArray.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,oBAAoB,KAA0C,CAAC;AASrE,MAAM,CAAC,OAAO,OAAO,kCAAmC,SAAQ,oBAAoB;;IAClF,MAAM,EAAE,kCAAkC,CAAC;IAE3C,MAAM,SAAK;gBAEC,KAAK,EAAE,kCAAkC,EAAE,KAAK,EAAE,MAAM;IAMpE,UAAU,IAAI,kCAAkC;IAUhD,QAAQ,IAAI,IAAI;IAIhB,QAAQ,IAAI,IAAI;CAIjB"}

package/lib/typescript/commonjs/src/utils/animated/AnimatedPoint.d.ts

@@ -0,0 +1,32 @@
+import { Animated } from "react-native";
+declare const AnimatedWithChildren: any;
+export declare class AnimatedPoint extends AnimatedWithChildren {
+    static [x: string]: any;
+    constructor(point?: {
+        type: string;
+        coordinates: number[];
+    });
+    setValue(point?: {
+        type: string;
+        coordinates: number[];
+    }): void;
+    setOffset(point?: {
+        type: string;
+        coordinates: number[];
+    }): void;
+    flattenOffset(): void;
+    stopAnimation(cb?: (value: GeoJSON.Point) => void): void;
+    addListener(cb?: (value: GeoJSON.Point) => void): string;
+    removeListener(id: string): void;
+    spring(config?: Partial<Animated.TimingAnimationConfig> & {
+        coordinates: GeoJSON.Position;
+    }): Animated.CompositeAnimation;
+    timing(config?: Partial<Animated.TimingAnimationConfig> & {
+        coordinates: GeoJSON.Position;
+    }): Animated.CompositeAnimation;
+    __getValue(): GeoJSON.Point;
+    __attach(): void;
+    __detach(): void;
+}
+export default AnimatedPoint;
+//# sourceMappingURL=AnimatedPoint.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/AnimatedPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/AnimatedPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAIxC,QAAA,MAAM,oBAAoB,KAA0C,CAAC;AAOrE,qBAAa,aAAc,SAAQ,oBAAoB;;gBACzC,KAAK;;;KAAgB;IAiBjC,QAAQ,CAAC,KAAK;;;KAAgB,GAAG,IAAI;IAKrC,SAAS,CAAC,KAAK;;;KAAgB,GAAG,IAAI;IAKtC,aAAa,IAAI,IAAI;IAKrB,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,GAAG,IAAI;IASxD,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,GAAG,MAAM;IAkBxD,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMhC,MAAM,CACJ,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC,GAAG;QAChD,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC;KACE,GACjC,QAAQ,CAAC,kBAAkB;IAe9B,MAAM,CACJ,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAC,GAAG;QAChD,WAAW,EAAE,OAAO,CAAC,QAAQ,CAAC;KACE,GACjC,QAAQ,CAAC,kBAAkB;IAe9B,UAAU,IAAI,OAAO,CAAC,KAAK;IAO3B,QAAQ,IAAI,IAAI;IAKhB,QAAQ,IAAI,IAAI;CAIjB;AAED,eAAe,aAAa,CAAC"}

package/lib/typescript/commonjs/src/utils/animated/AnimatedRouteCoordinatesArray.d.ts

@@ -0,0 +1,54 @@
+import { type Coord, type Units } from "@turf/helpers";
+import AbstractAnimatedCoordinates, { type AnimatedCoordinates } from "./AbstractAnimatedCoordinates";
+interface AnimatedRouteState {
+    actRoute?: AnimatedCoordinates[];
+    fullRoute: AnimatedCoordinates[];
+    end: {
+        from: number;
+        current?: number;
+        to: number;
+        point?: Coord;
+        along?: Coord;
+    };
+}
+export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoordinates<AnimatedRouteState> {
+    /**
+     * Calculate initial state
+     *
+     * @param {*} args - to value from animate
+     * @returns {object} - the state object
+     */
+    onInitialState(coordinatesArray: AnimatedCoordinates[]): AnimatedRouteState;
+    /**
+     * Calculate value from state.
+     *
+     * @param {object} state - either state from initialState and/or from calculate
+     * @returns {object}
+     */
+    onGetValue(state: AnimatedRouteState): AnimatedRouteState | AnimatedCoordinates[];
+    /**
+     * Calculates state based on startingState and progress, returns a new state
+     *
+     * @param {object} state - state object from initialState and/or from calculate
+     * @param {number} progress - value between 0 and 1
+     * @returns {object} next state
+     */
+    onCalculate(state: AnimatedRouteState, progress: number): AnimatedRouteState;
+    /**
+     * Subclasses can override to start a new animation
+     *
+     * @param {*} toValue - to value from animate
+     * @param {*} actCoords - the current coordinates array to start from
+     * @returns {object} The state
+     */
+    onStart(state: AnimatedRouteState, toValue: {
+        end: {
+            point?: Coord;
+            along?: number;
+        };
+        units?: Units;
+    }): AnimatedRouteState;
+    get originalRoute(): AnimatedCoordinates[];
+}
+export {};
+//# sourceMappingURL=AnimatedRouteCoordinatesArray.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/AnimatedRouteCoordinatesArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedRouteCoordinatesArray.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/AnimatedRouteCoordinatesArray.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,KAAK,EACX,MAAM,eAAe,CAAC;AAIvB,OAAO,2BAA2B,EAAE,EAClC,KAAK,mBAAmB,EACzB,MAAM,+BAA+B,CAAC;AAEvC,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACjC,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACjC,GAAG,EAAE;QACH,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,KAAK,CAAC,EAAE,KAAK,CAAC;KACf,CAAC;CACH;AAED,MAAM,CAAC,OAAO,OAAO,6BAA8B,SAAQ,2BAA2B,CAAC,kBAAkB,CAAC;IACxG;;;;;OAKG;IACH,cAAc,CAAC,gBAAgB,EAAE,mBAAmB,EAAE,GAAG,kBAAkB;IAS3E;;;;;OAKG;IACH,UAAU,CACR,KAAK,EAAE,kBAAkB,GACxB,kBAAkB,GAAG,mBAAmB,EAAE;IAI7C;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,kBAAkB;IAgC5E;;;;;;OAMG;IACH,OAAO,CACL,KAAK,EAAE,kBAAkB,EACzB,OAAO,EAAE;QAAE,GAAG,EAAE;YAAE,KAAK,CAAC,EAAE,KAAK,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,GACjE,kBAAkB;IA0CrB,IAAI,aAAa,IAAI,mBAAmB,EAAE,CAEzC;CACF"}

package/lib/typescript/commonjs/src/utils/animated/AnimatedShape.d.ts

@@ -0,0 +1,28 @@
+import { Animated } from "react-native";
+import AnimatedCoordinatesArray from "./AnimatedCoordinatesArray";
+import AnimatedExtractCoordinateFromArray from "./AnimatedExtractCoordinateFromArray";
+import AnimatedRouteCoordinatesArray from "./AnimatedRouteCoordinatesArray";
+declare const AnimatedWithChildren: any;
+type Shape = {
+    type: "Point";
+    coordinates: AnimatedExtractCoordinateFromArray | AnimatedRouteCoordinatesArray;
+} | {
+    type: "LineString";
+    coordinates: AnimatedCoordinatesArray;
+};
+/**
+ * AnimatedShape can be used to have animated properties inside the shape property
+ * @example
+ * <AnimatedShapeSource ... shape={new AnimatedShape({type:'LineString', coordinates: animatedCoords})} />
+ */
+declare class AnimatedShape extends AnimatedWithChildren {
+    static [x: string]: any;
+    constructor(shape: Shape);
+    _walkShapeAndGetValues(value: any): any;
+    __getValue(): any;
+    _walkAndProcess(value: any, cb: (value: Animated.Node) => void): void;
+    __attach(): void;
+    __detach(): void;
+}
+export default AnimatedShape;
+//# sourceMappingURL=AnimatedShape.d.ts.map

package/lib/typescript/commonjs/src/utils/animated/AnimatedShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedShape.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/animated/AnimatedShape.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAClE,OAAO,kCAAkC,MAAM,sCAAsC,CAAC;AACtF,OAAO,6BAA6B,MAAM,iCAAiC,CAAC;AAI5E,QAAA,MAAM,oBAAoB,KAA0C,CAAC;AASrE,KAAK,KAAK,GACN;IACE,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,EACP,kCAAkC,GAClC,6BAA6B,CAAC;CACnC,GACD;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,EAAE,wBAAwB,CAAC;CACvC,CAAC;AAEN;;;;GAIG;AACH,cAAM,aAAc,SAAQ,oBAAoB;;gBAIlC,KAAK,EAAE,KAAK;IAKxB,sBAAsB,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG;IAkBvC,UAAU,IAAI,GAAG;IAMjB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,KAAK,IAAI,GAAG,IAAI;IAarE,QAAQ,IAAI,IAAI;IAIhB,QAAQ,IAAI,IAAI;CAIjB;AAED,eAAe,aAAa,CAAC"}

package/lib/typescript/commonjs/src/utils/deprecation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copy properties from origObject to newObject, which not exists in newObject,
+ * calls onDeprecatedCalled callback in case a copied property is invoked.
+ */
+export declare function copyPropertiesAsDeprecated<DeprecatedType extends object, WithDeprecatedType extends Record<string, unknown>>(origObject: DeprecatedType, newObject: WithDeprecatedType, onDeprecatedCalled: (key: string) => void, accessors?: Record<string, (value: any) => unknown>): WithDeprecatedType;
+//# sourceMappingURL=deprecation.d.ts.map

package/lib/typescript/commonjs/src/utils/deprecation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deprecation.d.ts","sourceRoot":"","sources":["../../../../../src/utils/deprecation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,wBAAgB,0BAA0B,CACxC,cAAc,SAAS,MAAM,EAC7B,kBAAkB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAElD,UAAU,EAAE,cAAc,EAC1B,SAAS,EAAE,kBAAkB,EAC7B,kBAAkB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,EACzC,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAM,GACtD,kBAAkB,CAiBpB"}

package/lib/typescript/commonjs/src/utils/filterUtils.d.ts

@@ -0,0 +1,3 @@
+import { type FilterExpression } from "./MapLibreRNStyles";
+export declare function getFilter(filter: FilterExpression | undefined): string[];
+//# sourceMappingURL=filterUtils.d.ts.map

package/lib/typescript/commonjs/src/utils/filterUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterUtils.d.ts","sourceRoot":"","sources":["../../../../../src/utils/filterUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,wBAAgB,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,GAAG,MAAM,EAAE,CAMxE"}

package/lib/typescript/commonjs/src/utils/index.d.ts

@@ -0,0 +1,20 @@
+import { Children, Component, type ReactElement } from "react";
+import { type ImageSourcePropType } from "react-native";
+export declare function isAndroid(): boolean;
+export declare function existenceChange(cur: boolean, next: boolean): boolean;
+export declare function isFunction(fn: unknown): fn is boolean;
+export declare function isNumber(num: unknown): num is number;
+export declare function isUndefined(obj: unknown): obj is undefined;
+export declare function isString(str: unknown): str is string;
+export declare function isBoolean(bool: unknown): bool is boolean;
+export declare function isPrimitive(value: unknown): value is string | number | boolean;
+export type NativeArg = string | number | boolean | null | {
+    [k: string]: NativeArg;
+} | NativeArg[];
+export declare function runNativeCommand<ReturnType = NativeArg>(module: string, name: string, nativeRef: Component, args?: NativeArg[]): ReturnType;
+export declare function cloneReactChildrenWithProps(children: Parameters<typeof Children.map>[0], propsToAdd?: {
+    [key: string]: string;
+}): ReactElement[] | undefined;
+export declare function resolveImagePath(imageRef: ImageSourcePropType): string;
+export declare function toJSONString(json?: object | string): string;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAgB,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAC7E,OAAO,EAKL,KAAK,mBAAmB,EAEzB,MAAM,cAAc,CAAC;AAEtB,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAKpE;AAED,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAErD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,SAAS,CAE1D;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,OAAO,CAExD;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,GAAG,MAAM,GAAG,OAAO,CAEpC;AAED,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAC1B,SAAS,EAAE,CAAC;AAEhB,wBAAgB,gBAAgB,CAAC,UAAU,GAAG,SAAS,EACrD,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,SAAS,EACpB,IAAI,GAAE,SAAS,EAAO,GACrB,UAAU,CA0BZ;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAC5C,UAAU,GAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAO,GACzC,YAAY,EAAE,GAAG,SAAS,CAiB5B;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAGtE;AAED,wBAAgB,YAAY,CAAC,IAAI,GAAE,MAAM,GAAG,MAAW,GAAG,MAAM,CAE/D"}

package/lib/typescript/commonjs/src/utils/makeNativeBounds.d.ts

@@ -0,0 +1,2 @@
+export declare function makeNativeBounds(ne: GeoJSON.Position, sw: GeoJSON.Position): string;
+//# sourceMappingURL=makeNativeBounds.d.ts.map

package/lib/typescript/commonjs/src/utils/makeNativeBounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeNativeBounds.d.ts","sourceRoot":"","sources":["../../../../../src/utils/makeNativeBounds.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,EAAE,OAAO,CAAC,QAAQ,UAE1E"}

package/lib/typescript/commonjs/src/utils/styleMap.d.ts

@@ -0,0 +1,231 @@
+export declare const StyleTypes: {
+    Constant: string;
+    Color: string;
+    Transition: string;
+    Translation: string;
+    Function: string;
+    Image: string;
+    Enum: string;
+};
+export declare function getStyleType(styleProp: keyof typeof styleExtras): string;
+declare const styleMap: {
+    fillSortKey: string;
+    fillAntialias: string;
+    fillOpacity: string;
+    fillOpacityTransition: string;
+    fillColor: string;
+    fillColorTransition: string;
+    fillOutlineColor: string;
+    fillOutlineColorTransition: string;
+    fillTranslate: string;
+    fillTranslateTransition: string;
+    fillTranslateAnchor: string;
+    fillPattern: string;
+    fillPatternTransition: string;
+    lineCap: string;
+    lineJoin: string;
+    lineMiterLimit: string;
+    lineRoundLimit: string;
+    lineSortKey: string;
+    lineOpacity: string;
+    lineOpacityTransition: string;
+    lineColor: string;
+    lineColorTransition: string;
+    lineTranslate: string;
+    lineTranslateTransition: string;
+    lineTranslateAnchor: string;
+    lineWidth: string;
+    lineWidthTransition: string;
+    lineGapWidth: string;
+    lineGapWidthTransition: string;
+    lineOffset: string;
+    lineOffsetTransition: string;
+    lineBlur: string;
+    lineBlurTransition: string;
+    lineDasharray: string;
+    lineDasharrayTransition: string;
+    linePattern: string;
+    linePatternTransition: string;
+    lineGradient: string;
+    symbolPlacement: string;
+    symbolSpacing: string;
+    symbolAvoidEdges: string;
+    symbolSortKey: string;
+    symbolZOrder: string;
+    iconAllowOverlap: string;
+    iconIgnorePlacement: string;
+    iconOptional: string;
+    iconRotationAlignment: string;
+    iconSize: string;
+    iconTextFit: string;
+    iconTextFitPadding: string;
+    iconImage: string;
+    iconRotate: string;
+    iconPadding: string;
+    iconKeepUpright: string;
+    iconOffset: string;
+    iconAnchor: string;
+    iconPitchAlignment: string;
+    textPitchAlignment: string;
+    textRotationAlignment: string;
+    textField: string;
+    textFont: string;
+    textSize: string;
+    textMaxWidth: string;
+    textLineHeight: string;
+    textLetterSpacing: string;
+    textJustify: string;
+    textRadialOffset: string;
+    textVariableAnchor: string;
+    textAnchor: string;
+    textMaxAngle: string;
+    textWritingMode: string;
+    textRotate: string;
+    textPadding: string;
+    textKeepUpright: string;
+    textTransform: string;
+    textOffset: string;
+    textAllowOverlap: string;
+    textIgnorePlacement: string;
+    textOptional: string;
+    iconOpacity: string;
+    iconOpacityTransition: string;
+    iconColor: string;
+    iconColorTransition: string;
+    iconHaloColor: string;
+    iconHaloColorTransition: string;
+    iconHaloWidth: string;
+    iconHaloWidthTransition: string;
+    iconHaloBlur: string;
+    iconHaloBlurTransition: string;
+    iconTranslate: string;
+    iconTranslateTransition: string;
+    iconTranslateAnchor: string;
+    textOpacity: string;
+    textOpacityTransition: string;
+    textColor: string;
+    textColorTransition: string;
+    textHaloColor: string;
+    textHaloColorTransition: string;
+    textHaloWidth: string;
+    textHaloWidthTransition: string;
+    textHaloBlur: string;
+    textHaloBlurTransition: string;
+    textTranslate: string;
+    textTranslateTransition: string;
+    textTranslateAnchor: string;
+    circleSortKey: string;
+    circleRadius: string;
+    circleRadiusTransition: string;
+    circleColor: string;
+    circleColorTransition: string;
+    circleBlur: string;
+    circleBlurTransition: string;
+    circleOpacity: string;
+    circleOpacityTransition: string;
+    circleTranslate: string;
+    circleTranslateTransition: string;
+    circleTranslateAnchor: string;
+    circlePitchScale: string;
+    circlePitchAlignment: string;
+    circleStrokeWidth: string;
+    circleStrokeWidthTransition: string;
+    circleStrokeColor: string;
+    circleStrokeColorTransition: string;
+    circleStrokeOpacity: string;
+    circleStrokeOpacityTransition: string;
+    heatmapRadius: string;
+    heatmapRadiusTransition: string;
+    heatmapWeight: string;
+    heatmapIntensity: string;
+    heatmapIntensityTransition: string;
+    heatmapColor: string;
+    heatmapOpacity: string;
+    heatmapOpacityTransition: string;
+    fillExtrusionOpacity: string;
+    fillExtrusionOpacityTransition: string;
+    fillExtrusionColor: string;
+    fillExtrusionColorTransition: string;
+    fillExtrusionTranslate: string;
+    fillExtrusionTranslateTransition: string;
+    fillExtrusionTranslateAnchor: string;
+    fillExtrusionPattern: string;
+    fillExtrusionPatternTransition: string;
+    fillExtrusionHeight: string;
+    fillExtrusionHeightTransition: string;
+    fillExtrusionBase: string;
+    fillExtrusionBaseTransition: string;
+    fillExtrusionVerticalGradient: string;
+    rasterOpacity: string;
+    rasterOpacityTransition: string;
+    rasterHueRotate: string;
+    rasterHueRotateTransition: string;
+    rasterBrightnessMin: string;
+    rasterBrightnessMinTransition: string;
+    rasterBrightnessMax: string;
+    rasterBrightnessMaxTransition: string;
+    rasterSaturation: string;
+    rasterSaturationTransition: string;
+    rasterContrast: string;
+    rasterContrastTransition: string;
+    rasterResampling: string;
+    rasterFadeDuration: string;
+    hillshadeIlluminationDirection: string;
+    hillshadeIlluminationAnchor: string;
+    hillshadeExaggeration: string;
+    hillshadeExaggerationTransition: string;
+    hillshadeShadowColor: string;
+    hillshadeShadowColorTransition: string;
+    hillshadeHighlightColor: string;
+    hillshadeHighlightColorTransition: string;
+    hillshadeAccentColor: string;
+    hillshadeAccentColorTransition: string;
+    backgroundColor: string;
+    backgroundColorTransition: string;
+    backgroundPattern: string;
+    backgroundPatternTransition: string;
+    backgroundOpacity: string;
+    backgroundOpacityTransition: string;
+    anchor: string;
+    position: string;
+    positionTransition: string;
+    color: string;
+    colorTransition: string;
+    intensity: string;
+    intensityTransition: string;
+    visibility: string;
+};
+export declare const styleExtras: {
+    iconTextFitPadding: {
+        iosType: string;
+    };
+    iconOffset: {
+        iosType: string;
+    };
+    textOffset: {
+        iosType: string;
+    };
+    lineOffset: {
+        iosType: string;
+    };
+    fillTranslate: {
+        iosType: string;
+    };
+    lineTranslate: {
+        iosType: string;
+    };
+    iconTranslate: {
+        iosType: string;
+    };
+    textTranslate: {
+        iosType: string;
+    };
+    circleTranslate: {
+        iosType: string;
+    };
+    fillExtrusionTranslate: {
+        iosType: string;
+    };
+};
+export default styleMap;
+//# sourceMappingURL=styleMap.d.ts.map

package/lib/typescript/commonjs/src/utils/styleMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styleMap.d.ts","sourceRoot":"","sources":["../../../../../src/utils/styleMap.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;CAQtB,CAAC;AAEF,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,OAAO,WAAW,GAAG,MAAM,CAUxE;AAED,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoMb,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCvB,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/lib/typescript/module/jest.config.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jest.config.d.ts.map

package/lib/typescript/module/jest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../../../jest.config.ts"],"names":[],"mappings":""}

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/src/MLRNModule.d.ts

@@ -0,0 +1,21 @@
+import { CameraMode } from "./types/CameraMode";
+export declare const CameraModes: {
+    Flight: CameraMode.Flight;
+    Ease: CameraMode.Ease;
+    Linear: CameraMode.Linear;
+    None: CameraMode.None;
+}, StyleURL: {
+    Default: URL;
+}, OfflinePackDownloadState: {
+    Inactive: string | number;
+    Active: string | number;
+    Complete: string | number;
+    Unknown?: string | number;
+}, LineJoin: {
+    Bevel: string | number;
+    Round: string | number;
+    Miter: string | number;
+}, StyleSource: {
+    DefaultSourceID: string;
+}, setAccessToken: (accessToken: string | null) => Promise<string | null>, getAccessToken: () => Promise<string>, setConnected: (connected: boolean) => void;
+//# sourceMappingURL=MLRNModule.d.ts.map

package/lib/typescript/module/src/MLRNModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MLRNModule.d.ts","sourceRoot":"","sources":["../../../../src/MLRNModule.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAkChD,eAAO,MACL,WAAW;YA/BD,UAAU,CAAC,MAAM;UACnB,UAAU,CAAC,IAAI;YACb,UAAU,CAAC,MAAM;UACnB,UAAU,CAAC,IAAI;GA6BvB,QAAQ;aA1BG,GAAG;GA2Bd,wBAAwB;cAxBZ,MAAM,GAAG,MAAM;YACjB,MAAM,GAAG,MAAM;cACb,MAAM,GAAG,MAAM;cACf,MAAM,GAAG,MAAM;GAsB3B,QAAQ;WAnBC,MAAM,GAAG,MAAM;WACf,MAAM,GAAG,MAAM;WACf,MAAM,GAAG,MAAM;GAkBxB,WAAW;qBAfQ,MAAM;GAgBzB,cAAc,gBAbc,MAAM,GAAG,IAAI,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAclE,cAAc,QAbI,OAAO,CAAC,MAAM,CAAC,EAcjC,YAAY,cAbY,OAAO,KAAG,IActB,CAAC"}

package/lib/typescript/module/src/MapLibreRN.d.ts

@@ -0,0 +1,42 @@
+import { UserTrackingMode } from "./components/Camera";
+export * from "./MLRNModule";
+export { default as Camera, UserTrackingMode, type CameraPadding, type CameraAnimationMode, type CameraBounds, type CameraRef, } from "./components/Camera";
+export { default as MapView, type MapViewRef } from "./components/MapView";
+export { default as Light } from "./components/Light";
+export { default as PointAnnotation } from "./components/PointAnnotation";
+export type { PointAnnotationRef } from "./components/PointAnnotation";
+export { default as Annotation } from "./components/Annotation";
+export { default as Callout } from "./components/Callout";
+export { requestAndroidLocationPermissions } from "./requestAndroidLocationPermissions";
+export { default as UserLocation, UserLocationRenderMode, } from "./components/UserLocation";
+export type { UserLocationRef } from "./components/UserLocation";
+export { default as VectorSource } from "./components/VectorSource";
+export { default as ShapeSource } from "./components/ShapeSource";
+export type { ShapeSourceRef } from "./components/ShapeSource";
+export { default as RasterSource } from "./components/RasterSource";
+export { default as ImageSource } from "./components/ImageSource";
+export { default as Images } from "./components/Images";
+export { default as FillLayer } from "./components/FillLayer";
+export { default as FillExtrusionLayer } from "./components/FillExtrusionLayer";
+export { default as HeatmapLayer } from "./components/HeatmapLayer";
+export { default as LineLayer } from "./components/LineLayer";
+export { default as CircleLayer } from "./components/CircleLayer";
+export { default as SymbolLayer } from "./components/SymbolLayer";
+export { default as RasterLayer } from "./components/RasterLayer";
+export { default as BackgroundLayer } from "./components/BackgroundLayer";
+export { default as locationManager, type Location, } from "./modules/location/locationManager";
+export { default as offlineManager } from "./modules/offline/offlineManager";
+export type { OfflineProgressStatus, OfflinePackError, } from "./modules/offline/offlineManager";
+export type { OfflinePackStatus } from "./modules/offline/OfflinePack";
+export { default as OfflinePack } from "./modules/offline/OfflinePack";
+export { default as OfflineCreatePackOptions } from "./modules/offline/OfflineCreatePackOptions";
+export { default as snapshotManager } from "./modules/snapshot/snapshotManager";
+export type { SnapshotInputOptions } from "./modules/snapshot/SnapshotOptions";
+export { default as MarkerView } from "./components/MarkerView";
+export { default as Animated } from "./utils/animated/Animated";
+export { default as Style } from "./components/Style";
+export { default as Logger, type LogLevel } from "./utils/Logger";
+export type { FillLayerStyleProps as FillLayerStyle, LineLayerStyleProps as LineLayerStyle, SymbolLayerStyleProps as SymbolLayerStyle, CircleLayerStyleProps as CircleLayerStyle, HeatmapLayerStyleProps as HeatmapLayerStyle, FillExtrusionLayerStyleProps as FillExtrusionLayerStyle, RasterLayerStyleProps as RasterLayerStyle, HillshadeLayerStyleProps as HillshadeLayerStyle, BackgroundLayerStyleProps as BackgroundLayerStyle, LightLayerStyleProps as LightLayerStyle, } from "./utils/MapLibreRNStyles";
+/** @deprecated UserTrackingModes is deprecated use UserTrackingMode */
+export declare const UserTrackingModes: typeof UserTrackingMode;
+//# sourceMappingURL=MapLibreRN.d.ts.map