@mappable-world/mappable-types 0.0.1

package/modules/types.d.ts

@@ -0,0 +1,7 @@
+import "../import";
+declare module "../import" {
+    interface Import {
+        (pkg: "@mappable/mappable-controls-extra"): Promise<typeof import("./controls-extra")>;
+        (pkg: "@mappable/mappable-reactify"): Promise<typeof import("../reactify")>;
+    }
+}

package/modules/utils/MMapCursor/index.d.ts

@@ -0,0 +1,28 @@
+import { MMapComplexEntity, MMapEntity } from "../../../imperative/MMapEnities";
+import type { MMapHotspot } from "../../../imperative/MMapHotspot";
+type MMapCursorProps = {
+    /** Layer to follow */
+    layer?: string;
+    /** Cursor to set */
+    cursor?: string;
+    /** Function to control active cursor state */
+    isActive?: (object?: MMapEntity<unknown> | MMapHotspot) => boolean;
+};
+declare const defaultProps: Readonly<{
+    layer: "any";
+    cursor: "pointer";
+    isActive: (object: MMapEntity<unknown> | MMapHotspot) => boolean;
+}>;
+type DefaultProps = typeof defaultProps;
+declare class MMapCursor extends MMapComplexEntity<MMapCursorProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        layer: "any";
+        cursor: "pointer";
+        isActive: (object: MMapEntity<unknown, {}> | MMapHotspot) => boolean;
+    }>;
+    constructor(props: MMapCursorProps);
+    protected __implGetDefaultProps(): DefaultProps;
+    private _onMouseMove;
+    private _onMouseLeave;
+}
+export { MMapCursorProps, MMapCursor };

package/modules/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./MMapCursor";

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@mappable-world/mappable-types",
+    "version": "0.0.1",
+    "description": "Types for mappable maps library",
+    "main": "",
+    "types": "index.d.ts",
+    "keywords": [
+        "mappable",
+        "api",
+        "map",
+        "mappable",
+        "types",
+        "js api"
+    ],
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org"
+    },
+    "homepage": "https://mappable.world",
+    "license": "MIT"
+}

package/packages/cartesian-projection/index.d.ts

@@ -0,0 +1,49 @@
+import type { Projection, LngLat, WorldCoordinates } from "../../common/types";
+/**
+ * Creates a projection of a rectangular coordinate area into world coordinates.
+ * The area size in pixels is always 2*2.
+ *
+ * @name Cartesian
+ * @class Cartesian projection of a rectangular area.
+ * @augments Projection
+ * @param {[[Number, Number], [Number, Number]]} bounds An array of two points -
+ * coordinates of the lower left and upper right corners of the rectangular coordinate area.
+ * @param {Boolean[]} [cycled=[false, false]] An array of signs of map looping by x and y.
+ * @example
+ * ```js
+ * mappable.ready(async () => {
+ *     const {MMaps} = mappable;
+ *     // Calculate the size of all tiles at the maximum zoom.
+ *     const worldSize = Math.pow(2, MAX_ZOOM) * 256;
+ *     const PIC_WIDTH = 2526;
+ *     const PIC_HEIGHT = 1642;
+ *
+ *     const {Cartesian} = await mappable.import('@mappable/mappable-cartesian-projection@0.0.1');
+ *     // We set as a projection Cartesian. With this calculation, the center of the image will lie in the coordinates [0, 0].
+ *     const projection = new Cartesian([
+ *         [-PIC_WIDTH / 2, PIC_HEIGHT / 2 - worldSize],
+ *         [worldSize - PIC_WIDTH / 2, PIC_HEIGHT / 2],
+ *     ]);
+ *
+ *     const map = new MMaps({
+ *         //...,
+ *         projection: projection
+ *     });
+ * });
+ * ```
+ */
+export declare class Cartesian implements Projection {
+    private _bounds;
+    private _cycled;
+    private _xRange;
+    private _yRange;
+    constructor(bounds: [
+        LngLat,
+        LngLat
+    ], cycled?: [
+        boolean,
+        boolean
+    ]);
+    toWorldCoordinates(point: LngLat): WorldCoordinates;
+    fromWorldCoordinates(point: WorldCoordinates): LngLat;
+}

package/packages/clusterer/MMapClusterer/MMapClusterer.d.ts

@@ -0,0 +1,108 @@
+import type { MMapEntity } from "../../..";
+import type { LngLat } from "../../../common/types";
+import { reactify } from "../../../reactify";
+import type { ClustererObject, Feature, IClusterMethod } from "./interface";
+/**
+ * MMapClusterer props
+ */
+type MMapClustererProps = {
+    /** Clusterisation method */
+    method: IClusterMethod;
+    /** Features */
+    features: Feature[];
+    /** Function to create marker for point*/
+    marker: (feature: Feature) => MMapEntity<unknown>;
+    /** Function to create marker for cluster*/
+    cluster: (coordinates: LngLat, features: Feature[]) => MMapEntity<unknown>;
+    /** The amount of time that may be passed before the render method can be called again */
+    tickTimeout?: number;
+    /** Return false, if you want to override the render */
+    onRender?: (clusters: ClustererObject[]) => void | false;
+};
+type DefaultProps = typeof defaultProps;
+declare const defaultProps: Readonly<{
+    tickTimeout: 100;
+}>;
+/**
+ * Display clustered features on a map.
+ *
+ * @example
+ * ```javascript
+ * const clusterer = new MMapClusterer({
+ *      method: clusterByGrid({gridSize: 64}),
+ *      features: POINTS,
+ *      marker: (feature) => new MMapMarker({
+ *          coordinates: feature.geometry.coordinates,
+ *          source: 'my-source'
+ *      }
+ *      cluster: (coordinates, cluster) => new MMapMarker({
+ *          coordinates,
+ *          source: 'my-source'
+ *      }
+ * });
+ *
+ * map.addChild(new MMapDefaultSchemeLayer())
+ *      .addChild(new MMapFeatureDataSource({id: 'my-source'}))
+ *      .addChild(new MMapLayer({source: 'my-source', type: 'markers'}))
+ *      .addChild(clusterer);
+ * ```
+ */
+declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        tickTimeout: 100;
+    }>;
+    /** @internal */
+    static [reactify.overrideKey]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<MMapClustererProps & {
+        marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    } & import("react").RefAttributes<MMapEntity<MMapClustererProps & {
+        marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    }, {}>>>>;
+    /** All created entities with cluster id*/
+    private _entitiesData;
+    /** Viewport entities with cluster id */
+    private _visibleEntities;
+    /** Store to add entities on a map */
+    private _container;
+    /** Listener on map update and resize */
+    private _mapListener;
+    constructor(props: MMapClustererProps);
+    /**
+         * Compare feature coordinates with bounds
+         *
+         * @param feature
+         * @param bounds
+         * @param projection
+         * @returns either feature belongs to viewport or not
+         */
+    private _isVisible;
+    /**
+         * Get entity from store or create it
+         *
+         * @param feature
+         * @param entityId
+         * @param length count of entities in the cluster
+         * @returns ready to add to map entity
+         */
+    private _getEntity;
+    /**
+         * Generate map of new entities based on returned from method objects
+         *
+         * @param nextViewportObjects clustered objects
+         * @returns map of entities for new render
+         */
+    private _getVisibleEntities;
+    /**
+         * Removes unnecessary entities and adds new to the map
+         *
+         * @param nextVisibleEntities new entities for matching with existing entities
+         */
+    private _syncVisibleEntities;
+    private _render;
+    protected __implGetDefaultProps(): DefaultProps;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(): void;
+}
+export { MMapClusterer, MMapClustererProps };

package/packages/clusterer/MMapClusterer/constants.d.ts

@@ -0,0 +1 @@
+export declare const THROTTLE_DEFAULT_TIMEOUT_MS = 100;

package/packages/clusterer/MMapClusterer/helpers/throttle.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Throttles a function and delays its execution, so it's only called at most
+ * once within a given time period.
+ *
+ * @param {Function} fn The function to throttle.
+ * @param {number} wait The amount of time that must pass before the function can be called again.
+ * @return {Function} The throttled function.
+ */
+/**
+ * Throttles a function and delays its execution, so it's only called at most
+ * once within a given time period.
+ *
+ * @param {Function} fn The function to throttle.
+ * @param {number} wait The amount of time that must pass before the function can be called again.
+ * @return {Function} The throttled function.
+ */
+export declare const throttle: (fn: Function, wait: number) => (this: any) => void;

package/packages/clusterer/MMapClusterer/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./interface";
+export * from "./MMapClusterer";
+export * from "./methods";

package/packages/clusterer/MMapClusterer/interface.d.ts

@@ -0,0 +1,31 @@
+import type { MMap, MMapEntity } from "../../..";
+import type { LngLat, WorldCoordinates, GenericPointFeature } from "../../../common/types";
+/** Represents object on a map (either cluster or feature) */
+type ClustererObject = {
+    world: WorldCoordinates;
+    lnglat: LngLat;
+    clusterId: string;
+    features: Feature[];
+};
+/** Feature to clusterize on a map */
+type Feature = GenericPointFeature<LngLat>;
+/** Cluster that contains cluster or feature and its sum of coordinates */
+type Cluster = {
+    sumX: number;
+    sumY: number;
+    objects: ClustererObject[];
+    features: Feature[];
+};
+type ClustersCollection = Map<string, Cluster>;
+/** Props for rendering */
+type RenderProps = {
+    map: MMap;
+    features: Feature[];
+};
+/** Represents map of entities with its id */
+type EntitiesMap = Record<string, MMapEntity<unknown> | undefined>;
+/** Interface of method class*/
+interface IClusterMethod {
+    render(props: RenderProps): ClustererObject[];
+}
+export type { EntitiesMap, ClustersCollection, ClustererObject, Feature, IClusterMethod, RenderProps };

package/packages/clusterer/MMapClusterer/methods/clusterByGrid.d.ts

@@ -0,0 +1,4 @@
+import type { IClusterMethod } from "../interface";
+export declare function clusterByGrid({ gridSize }: {
+    gridSize: number;
+}): IClusterMethod;

package/packages/clusterer/MMapClusterer/methods/index.d.ts

@@ -0,0 +1 @@
+export { clusterByGrid } from "./clusterByGrid";

package/packages/clusterer/MMapClusterer/react/MMapClusterer.d.ts

@@ -0,0 +1,44 @@
+import type TReact from "react";
+import type { LngLat, MMapEntity } from "../../../..";
+import type { CustomReactify } from "../../../../reactify/reactify";
+import type { Feature } from "../interface";
+import type { MMapClusterer as MMapClustererI, MMapClustererProps } from "../MMapClusterer";
+/**
+ * Create reactified version of MMapCluster module
+ *
+ * @example
+ * ```jsx
+ * <MMap location={LOCATION} ref={x => map = x}>
+ *     <MMapDefaultSchemeLayer />
+ *     <MMapFeatureDataSource id="my-source"/>
+ *     <MMapLayer source="my-source" type="markers" zIndex={1800}/>
+ *     <MMapClusterer
+ *         marker={(feature) => <MMapMarker
+ *             coordinates={feature.geometry.coordinates}
+ *             source={'my-source'} >
+ *                 <img src={'./pin.svg'}/>
+ *             </MMapMarker>}
+ *         cluster={(coordinates, features) => <MMapMarker
+ *             coordinates={coordinates}
+ *             source={'my-source'} >
+ *             <div className="circle">
+ *                 <div className="circle-content">
+ *                     <span className="circle-text">{features.length}</span>
+ *                 </div>
+ *             </div>
+ *             </MMapMarker>}
+ *         method={gridSizedMethod}
+ *         features={points}
+ *     />
+ * </MMap>
+ * ```
+ */
+type MMapClustererReactifiedProps = MMapClustererProps & {
+    /** Function that returns MMapMarker react component to render marker*/
+    marker: (feature: Feature) => TReact.ReactElement;
+    /** Function that returns MMapMarker react component to render cluster*/
+    cluster: (coordinates: LngLat, features: Feature[]) => TReact.ReactElement;
+};
+type MMapClustererR = TReact.ForwardRefExoticComponent<MMapClustererReactifiedProps & React.RefAttributes<MMapEntity<MMapClustererReactifiedProps>>>;
+export declare const MMapClustererReactifyOverride: CustomReactify<MMapClustererI, MMapClustererR>;
+export {};

package/packages/clusterer/index.d.ts

@@ -0,0 +1 @@
+export * from "./MMapClusterer/index";

package/packages/clusterer/react/index.d.ts

@@ -0,0 +1,3 @@
+type Module = import("../../../reactify").ReactifiedModule<typeof import("../index")>;
+declare const module: Module;
+export = module;

package/packages/controls/MMapGeolocationControl/MMapControlSpinner/index.d.ts

@@ -0,0 +1,6 @@
+declare class MMapControlSpinner extends mappable.MMapComplexEntity<{}> {
+    private _detachDom?;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+}
+export { MMapControlSpinner };

package/packages/controls/MMapGeolocationControl/index.d.ts

@@ -0,0 +1,54 @@
+import type { EasingFunctionDescription, LngLat } from "../../../common/types";
+/**
+ * MMapGeolocationControl props
+ */
+type MMapGeolocationControlProps = {
+    /** Geolocation request callback */
+    onGeolocatePosition?: (position: LngLat) => void;
+    /** Data source id for geolocation placemark */
+    source?: string;
+    /** Easing function for map location animation */
+    easing?: EasingFunctionDescription;
+    /** Map location animate duration */
+    duration?: number;
+};
+declare const defaultProps: Readonly<{
+    duration: 500;
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * Display geolocation control on a map.
+ *
+ * @example
+ * ```javascript
+ * const controls = new MMapControls({position: 'right'});
+ * const geolocationControl = new MMapGeolocationControl();
+ * controls.addChild(geolocationControl);
+ * map.addChild(controls);
+ * ```
+ */
+declare class MMapGeolocationControl extends mappable.MMapGroupEntity<MMapGeolocationControlProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        duration: 500;
+    }>;
+    private _control;
+    private _button;
+    private _spinner;
+    private _marker;
+    private _loading;
+    private _element;
+    private _unwatchMapContext?;
+    constructor(props: MMapGeolocationControlProps);
+    protected __implGetDefaultProps(): DefaultProps;
+    private _timeout;
+    private _setLoading;
+    private _position;
+    private _updatePosition;
+    private _handleGeolocationClick;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(props: Partial<MMapGeolocationControlProps>): void;
+    private _initMarker;
+    private _updateMarkerIcon;
+}
+export { MMapGeolocationControl, MMapGeolocationControlProps };

package/packages/controls/MMapZoomControl/index.d.ts

@@ -0,0 +1,45 @@
+import type { EasingFunctionDescription } from "../../../common/types";
+import type { MMapControlCommonButton } from "../../../imperative/MMapControl";
+import type { MMapListener } from "../../../imperative/MMapListener";
+/**
+ * MMapZoomControl props
+ */
+type MMapZoomControlProps = {
+    /** Easing function for map location animation */
+    easing?: EasingFunctionDescription;
+    /** Map location animate duration */
+    duration?: number;
+};
+declare const defaultProps: Readonly<{
+    duration: 200;
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * Display zoom control on a map.
+ *
+ * @example
+ * ```javascript
+ * const controls = new MMapControls({position: 'right'});
+ * const {MMapZoomControl} = await mappable.import('@mappable/mappable-controls@0.0.1');
+ * const zoomControl = new MMapZoomControl();
+ * controls.addChild(zoomControl);
+ * map.addChild(controls);
+ * ```
+ */
+declare class MMapZoomControl extends mappable.MMapControl<MMapZoomControlProps> {
+    static defaultProps: Readonly<{
+        duration: 200;
+    }>;
+    protected _zoomIn: MMapControlCommonButton;
+    protected _zoomOut: MMapControlCommonButton;
+    protected _listener: MMapListener;
+    private _currentZoom;
+    constructor(props: MMapZoomControlProps);
+    protected __implGetDefaultProps(): DefaultProps;
+    private _onMapUpdate;
+    private _changeZoom;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(props: MMapZoomControlProps): void;
+}
+export { MMapZoomControl, MMapZoomControlProps };

package/packages/controls/index.d.ts

@@ -0,0 +1,2 @@
+export { MMapZoomControl, MMapZoomControlProps } from "./MMapZoomControl";
+export { MMapGeolocationControl, MMapGeolocationControlProps } from "./MMapGeolocationControl";

package/packages/controls/react/index.d.ts

@@ -0,0 +1,3 @@
+type Module = import("../../../reactify").ReactifiedModule<typeof import("../index")>;
+declare const module: Module;
+export = module;

package/packages/external.d.ts

@@ -0,0 +1,2 @@
+import * as mappable from "../imperative";
+export { mappable };

package/packages/hint/MMapHint/index.d.ts

@@ -0,0 +1,57 @@
+import type TReact from "react";
+import type { MMapFeature, MMapMarker, MMapHotspot } from "../../../imperative";
+import type { CustomReactify } from "../../../reactify/reactify";
+import { reactify } from "../../../reactify";
+type MMapHintProps = {
+    hint: (object: MMapFeature | MMapMarker | MMapHotspot | undefined) => unknown;
+};
+declare const MMapHintContext: import("../../../imperative/Entities").Context<unknown>;
+/**
+ * Display hint on map elements.
+ *
+ * @example
+ * ```javascript
+ * const {MMapHint, MMapHintContext} = await mappable.import('@mappable/mappable-hint@0.0.1');
+ * map.addChild(defaultFeatures = new MMapDefaultFeaturesLayer());
+ * map.addChild(hint = MMapHint({
+ *    layers: [defaultFeatures.layer],
+ *    hint: object => object?.properties?.hint
+ * }));
+ *
+ * const {MMapDefaultMarker} = await mappable.import('@mappable/mappable-markers@0.0.1');
+ * map.addChild(new MMapDefaultMarker({coordinates: [37, 55], properties: {hint: 'Hello world!'}}));
+ *
+ * hint.addChild(new class MyHint extends mappable.MMapEntity {
+ *    _onAttach() {
+ *         this._element = document.createElement('div');
+ *         this._element.className = 'my-hint';
+ *
+ *         this._detachDom = mappable.useDomContext(this, this._element);
+ *         this._watchContext(MMapHintContext, () => {
+ *              this._element.textContent = this._consumeContext(MMapHintContext)?.hint;
+ *         }, {immediate: true});
+ *    }
+ *
+ *    _onDetach() {
+ *        this._detachDom();
+ *    }
+ * });
+ * ```
+ */
+declare class MMapHint extends mappable.MMapGroupEntity<MMapHintProps> {
+    /** @internal */
+    static [reactify.overrideKey]: CustomReactify<MMapHint, TReact.FC<MMapHintProps>>;
+    private _destroyDomContext;
+    private _detachDom;
+    private _element;
+    private _hintElement;
+    constructor(props: MMapHintProps);
+    protected _positionHintElement(screenCoordinates: [
+        number,
+        number
+    ]): void;
+    protected _toggleHint(add: boolean): void;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+}
+export { MMapHint, MMapHintContext };

package/packages/hint/index.d.ts

@@ -0,0 +1 @@
+export { MMapHint, MMapHintContext } from "./MMapHint";

package/packages/hint/react/index.d.ts

@@ -0,0 +1,3 @@
+type Module = import("../../../reactify").ReactifiedModule<typeof import("../index")>;
+declare const module: Module;
+export = module;

package/packages/markers/MMapDefaultMarker/index.d.ts

@@ -0,0 +1,77 @@
+import type { LngLat } from "../../../common/types";
+import type { MMapMarkerProps } from "../../../imperative/MMapMarker";
+import { reactify } from "../../../reactify";
+type DefaultMarkerCustomProps = {
+    /** Marker title */
+    title?: string;
+    /** Marker subtitle */
+    subtitle?: string;
+    /** Marker icon color */
+    color?: string;
+    /** Popup */
+    popup?: {
+        /** Popup content */
+        content: string | ((close: () => void) => HTMLElement);
+        /** Popup position */
+        position: "left" | "right" | "top";
+        /** Should popup hide marker. Default is false */
+        hidesMarker?: boolean;
+    };
+};
+/**
+ * MMapDefaultMarker props
+ */
+type MMapDefaultMarkerProps = MMapMarkerProps & DefaultMarkerCustomProps;
+declare const defaultProps: Readonly<{
+    color: "#f33";
+}>;
+type DefaultProps = typeof defaultProps;
+/**
+ * Default marker.
+ *
+ * @example
+ * ```javascript
+ * const {MMapDefaultMarker} = await mappable.import('@mappable/mappable-markers@0.0.1');
+ * map.addChild(new MMapDefaultMarker({
+ *     coordinates: [34, 54],
+ *     title: 'Hello World!',
+ *     subtitle: 'kind and bright',
+ *     color: 'blue'
+ * }));
+ * ```
+ */
+declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMarkerProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        color: "#f33";
+    }>;
+    /** @internal */
+    static [reactify.overrideKey]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
+        coordinates: LngLat;
+        source?: string | undefined;
+        zIndex?: number | undefined;
+        properties?: Record<string, unknown> | undefined;
+        id?: string | undefined;
+    } & import("../../../imperative/MMapFeature/types").DraggableProps<import("../../../imperative/MMapMarker").MMapMarkerEventHandler> & import("../../../imperative/MMapFeature/types").FeatureClickEvents & DefaultMarkerCustomProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<import("../../../imperative/MMapEnities").MMapEntity<MMapDefaultMarkerProps, {}>>>>;
+    private _marker;
+    private _container;
+    private _popup;
+    private _popupIsOpen;
+    private _popupProps;
+    get coordinates(): LngLat;
+    constructor(props: MMapDefaultMarkerProps);
+    private _createMarker;
+    private __onElementClick;
+    protected __implGetDefaultProps(): DefaultProps;
+    private _togglePopup;
+    private _createPopup;
+    protected _onUpdate(changedProps: Partial<MMapDefaultMarkerProps>): void;
+    private _getElement;
+    /**
+         * Hides/shows marker labels depending on whether they are empty
+         */
+    private _toggleCaption;
+    private _createContainer;
+}
+export { MMapDefaultMarker, MMapDefaultMarkerProps, DefaultMarkerCustomProps };

package/packages/markers/MMapDefaultMarker/react/MMapDefaultMarker.d.ts

@@ -0,0 +1,8 @@
+import type TReactNamespace from "react";
+import type { CustomReactify } from "../../../../reactify/reactify";
+import type { MMapEntity } from "../../../..";
+import { MMapDefaultMarker, MMapDefaultMarkerProps } from "../index";
+type MMapDefaultMarkerContainerProps = TReactNamespace.PropsWithChildren<MMapDefaultMarkerProps>;
+type MMapDefaultMarkerR = TReactNamespace.ForwardRefExoticComponent<MMapDefaultMarkerContainerProps & React.RefAttributes<MMapEntity<MMapDefaultMarkerProps>>>;
+export declare const MMapDefaultMarkerReactifyOverride: CustomReactify<MMapDefaultMarker, MMapDefaultMarkerR>;
+export {};

package/packages/markers/index.d.ts

@@ -0,0 +1 @@
+export { MMapDefaultMarker, MMapDefaultMarkerProps } from "./MMapDefaultMarker";

package/packages/markers/react/index.d.ts

@@ -0,0 +1,3 @@
+type Module = import("../../../reactify").ReactifiedModule<typeof import("../index")>;
+declare const module: Module;
+export = module;