Default Marker Pack

Class: MMapDefaultMarkerClass: MMapDefaultMarker

Default marker.

Example

const {MMapDefaultMarker} = await mappable.import('@mappable-world/mappable-markers@0.0.1');
map.addChild(new MMapDefaultMarker({
    coordinates: [34, 54],
    title: 'Hello World!',
    subtitle: 'kind and bright',
    color: 'blue'
}));

ConstructorsConstructors

constructorconstructor

new MMapDefaultMarker(props)

ParametersParameters

Name	Type
props	MMapDefaultMarkerProps

OverridesOverrides

MMapComplexEntity.constructor

PropertiesProperties

[optionsKeyVuefy][optionsKeyVuefy]

static [optionsKeyVuefy]: CustomVuefyOptions<MMapDefaultMarker, MMapDefaultMarkerProps>

---

[overrideKeyReactify][overrideKeyReactify]

static [overrideKeyReactify]: CustomReactify<MMapDefaultMarker, ForwardRefExoticComponent<{
	blockBehaviors?: boolean;
	blockEvents?: boolean;
	children?: ReactNode;
	color?: string;
	coordinates: LngLat;
	disableRoundCoordinates?: boolean;
	draggable?: boolean;
	hideOutsideViewport?: HideOutsideRule;
	id?: string;
	key?: null | Key;
	mapFollowsOnDrag?: boolean | {
	activeZoneMargin?: Margin 
};
	onClick?: (`event`: MouseEvent, `mapEvent`: MapEvent) => void;
	onDoubleClick?: (`event`: MouseEvent, `mapEvent`: MapEvent) => void;
	onDragEnd?: MMapMarkerEventHandler;
	onDragMove?: MMapMarkerEventHandler;
	onDragStart?: MMapMarkerEventHandler;
	onFastClick?: (`event`: MouseEvent, `mapEvent`: MapEvent) => void;
	popup?: {
		content: string | (`close`: () => void) => HTMLElement;
		hidesMarker?: boolean;
		position: "left" | "top" | "right" 
	};
	properties?: Record<string, unknown>;
	ref?: Ref<MMapEntity<MMapDefaultMarkerProps, {}>>;
	source?: string;
	subtitle?: string;
	title?: string;
	zIndex?: number 
}>>

---

[overrideKeyVuefy][overrideKeyVuefy]

static [overrideKeyVuefy]: CustomVuefyFn<MMapDefaultMarker, MMapDefaultMarkerProps>

---

defaultPropsdefaultProps

static defaultProps: Readonly<{
	color: "#f33";
	hideOutsideViewport: true 
}>

AccessorsAccessors

coordinatescoordinates

get coordinates(): LngLat

ReturnsReturns

LngLat

---

parentparent

get parent(): null | MMapComplexEntity<unknown, {}>

Get parent entity.

ReturnsReturns

null | MMapComplexEntity<unknown, {}>

Inherited fromInherited from

mappable.MMapComplexEntity.parent

---

rootroot

get root(): null | MMap

Get root entity.

ReturnsReturns

null | MMap

Inherited fromInherited from

mappable.MMapComplexEntity.root

MethodsMethods

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<MMapDefaultMarkerProps>	New props values.

ReturnsReturns

void

Inherited fromInherited from

MMapComplexEntity.update

Class: ConfigClass: Config

Configuration object for whole API.
For example, it can be used to set experiments or apikeys.

mappable.getDefaultConfig().setApikeys({search: "YOUR_SEARCH_API_KEY"})`.

ConstructorsConstructors

constructorconstructor

new Config()

PropertiesProperties

descriptiondescription

readonly description: string

MethodsMethods

setApikeyssetApikeys

setApikeys(apikeys): void

Set apikeys for http-services.

mappable.getDefaultConfig().setApikeys({search: "YOUR_SEARCH_API_KEY"})`.

ParametersParameters

Name	Type
apikeys	Apikeys

ReturnsReturns

void

---

setExperimentssetExperiments

setExperiments(experiments): void

Set experiments for map.

ParametersParameters

Name	Type
experiments	Record<string, boolean>

ReturnsReturns

void

Class: Context<_TClass: Context<_T>

Type parametersType parameters

Name
_T

ConstructorsConstructors

constructorconstructor

new Context<_T>(name)

Type parametersType parameters

Name
_T

ParametersParameters

Name	Type
name	string

PropertiesProperties

namename

readonly name: string

Class: GenericComplexEntity<Props, DefaultProps, RootClass: GenericComplexEntity<Props, DefaultProps, Root>

Entity that aggregates multiple Entities but looks basic from the outside.

Example

type MMapSomeComplexEntityProps = {
 name?: string;
};
const defaultProps = {
 name: 'entity'
};
class MMapSomeComplexEntity extends GenericComplexEntity<MMapSomeComplexEntityProps, typeof defaultProps> {
 static defaultProps = defaultProps;
 private _someEntity?: MMapSomeEntity; // MMapSomeEntity extends GenericEntity
 protected _onAttach(): void {
     this._someEntity = new MMapSomeEntity();
     this.addChild(this._someEntity); // add someEntity as children
     // ...
 }
 // ...
}

Type parametersType parameters

Name	Type	Description
Props	Props	Type of input props of the Entity.
DefaultProps	extends Object = {}	Type of default input props of the Entity.
Root	extends GenericRootEntity<unknown> = GenericRootEntity<unknown>	Root Entity Class.

ConstructorsConstructors

constructorconstructor

new GenericComplexEntity<Props, DefaultProps, Root>(props, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}
Root	extends GenericRootEntity<unknown, {}, Root> = GenericRootEntity<unknown, {}>

ParametersParameters

Name	Type	Description
props	Props	The value of input props.
options?	ComplexOptions<Root>	Optional options object.

OverridesOverrides

GenericEntity.constructor

new GenericComplexEntity<Props, DefaultProps, Root>(props, children?, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}
Root	extends GenericRootEntity<unknown, {}, Root> = GenericRootEntity<unknown, {}>

ParametersParameters

Name	Type
props	Props
children?	GenericEntity<unknown, {}, Root>[]
options?	Omit<ComplexOptions<Root>, "children">

OverridesOverrides

GenericEntity<Props, DefaultProps, Root&gt;.constructor

AccessorsAccessors

parentparent

get parent(): null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Get parent entity.

ReturnsReturns

null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Inherited fromInherited from

GenericEntity.parent

---

rootroot

get root(): null | Root

Get root entity.

ReturnsReturns

null | Root

Inherited fromInherited from

GenericEntity.root

MethodsMethods

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<Props>	New props values.

ReturnsReturns

void

Inherited fromInherited from

GenericEntity.update

Class: GenericEntity<Props, DefaultProps, RootClass: GenericEntity<Props, DefaultProps, Root>

Entity Base Class. It has event handlers for attaching, detaching and updating props. Has a method for providing and using context.

Example

type MMapSomeEntityProps = {
 name?: string;
};
const defaultProps = {
 name: 'entity'
};
class MMapSomeEntity extends GenericEntity<MMapSomeEntityProps, typeof defaultProps> {
 static defaultProps = defaultProps;
 public isAttached: boolean;
 constructor(props: MMapSomeEntityProps) {
     super(props);
     this.isAttached = false
     // Additional actions can be taken in the constructor of a class.
 }
 protected _onAttach(): void {
     this.isAttached = true;
     // Additional actions can be taken when an Entity is attached.
 }
 // ...
}

Type parametersType parameters

Name	Type	Description
Props	Props	Type of input props of the Entity.
DefaultProps	extends Object = {}	Type of default input props of the Entity.
Root	extends GenericRootEntity<unknown> = GenericRootEntity<unknown>	Root Entity Class.

ConstructorsConstructors

constructorconstructor

new GenericEntity<Props, DefaultProps, Root>(props)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}
Root	extends GenericRootEntity<unknown, {}, Root> = GenericRootEntity<unknown, {}>

ParametersParameters

Name	Type	Description
props	Props	The value of input props.

AccessorsAccessors

parentparent

get parent(): null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Get parent entity.

ReturnsReturns

null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

---

rootroot

get root(): null | Root

Get root entity.

ReturnsReturns

null | Root

MethodsMethods

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<Props>	New props values.

ReturnsReturns

void

Class: GenericGroupEntity<Props, DefaultProps, RootClass: GenericGroupEntity<Props, DefaultProps, Root>

Entity that aggregates multiple Entities, and allows you to publicly add and remove entities to a subtree.

Example

type MMapSomeGroupEntityProps = {
 name?: string;
};
const defaultProps = {
 name: 'entity'
};
class MMapSomeGroupEntity extends GenericGroupEntity<MMapSomeGroupEntityProps, typeof defaultProps> {
 static defaultProps = defaultProps;
 // ...
}
const groupEntity = new MMapSomeGroupEntity()
const someEntity = new MMapSomeEntity(); // MMapSomeEntity extends GenericEntity
groupEntity.addChild(someEntity); // add someEntity in MMapSomeGroupEntity object
groupEntity.removeChild(someEntity); // remove someEntity from MMapSomeGroupEntity object

Type parametersType parameters

Name	Type	Description
Props	Props	Type of input props of the Entity.
DefaultProps	extends Object = {}	Type of default input props of the Entity.
Root	extends GenericRootEntity<unknown> = GenericRootEntity<unknown>	Root Entity Class.

ConstructorsConstructors

constructorconstructor

new GenericGroupEntity<Props, DefaultProps, Root>(props, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}
Root	extends GenericRootEntity<unknown, {}, Root> = GenericRootEntity<unknown, {}>

ParametersParameters

Name	Type	Description
props	Props	The value of input props.
options?	ComplexOptions<Root>	Optional options object.

Inherited fromInherited from

GenericComplexEntity.constructor

new GenericGroupEntity<Props, DefaultProps, Root>(props, children?, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}
Root	extends GenericRootEntity<unknown, {}, Root> = GenericRootEntity<unknown, {}>

ParametersParameters

Name	Type
props	Props
children?	GenericEntity<unknown, {}, Root>[]
options?	Omit<ComplexOptions<Root>, "children">

Inherited fromInherited from

GenericComplexEntity.constructor

PropertiesProperties

childrenchildren

readonly children: readonly GenericEntity<unknown, {}, Root>[]

OverridesOverrides

GenericComplexEntity.children

AccessorsAccessors

parentparent

get parent(): null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Get parent entity.

ReturnsReturns

null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Inherited fromInherited from

GenericComplexEntity.parent

---

rootroot

get root(): null | Root

Get root entity.

ReturnsReturns

null | Root

Inherited fromInherited from

GenericComplexEntity.root

MethodsMethods

addChildaddChild

addChild(child, index?): GenericGroupEntity<Props, DefaultProps, Root>

ParametersParameters

Name	Type
child	GenericEntity<unknown, {}, Root>
index?	number

ReturnsReturns

GenericGroupEntity<Props, DefaultProps, Root>

OverridesOverrides

GenericComplexEntity.addChild

---

removeChildremoveChild

removeChild(child): GenericGroupEntity<Props, DefaultProps, Root>

ParametersParameters

Name	Type
child	GenericEntity<unknown, {}, Root>

ReturnsReturns

GenericGroupEntity<Props, DefaultProps, Root>

OverridesOverrides

GenericComplexEntity.removeChild

---

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<Props>	New props values.

ReturnsReturns

void

Inherited fromInherited from

GenericComplexEntity.update

Class: GenericRootEntity<Props, DefaultPropsClass: GenericRootEntity<Props, DefaultProps>

Entity that is root and cannot be added anywhere

Example

type MMapProps = {
 name?: string;
};
class MMap extends GenericRootEntity<MMapProps, typeof defaultProps> {
 // ...
}
// Now we can specify their root element for the Entity
class MMapSomeEntity extends GenericEntity<MMapSomeEntityProps, typeof defaultProps, MMap> {
 static defaultProps = defaultProps;
 // ...
}

Type parametersType parameters

Name	Type	Description
Props	Props	Type of input props of the Entity.
DefaultProps	extends Object = {}	Type of default input props of the Entity.

ConstructorsConstructors

constructorconstructor

new GenericRootEntity<Props, DefaultProps>(props, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}

ParametersParameters

Name	Type	Description
props	Props	The value of input props.
options?	ComplexOptions<GenericRootEntity<unknown, {}>>	Optional options object.

Inherited fromInherited from

GenericGroupEntity.constructor

new GenericRootEntity<Props, DefaultProps>(props, children?, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}

ParametersParameters

Name	Type
props	Props
children?	GenericEntity<unknown, {}, GenericRootEntity<unknown, {}>>[]
options?	Omit<ComplexOptions<GenericRootEntity<unknown, {}>>, "children">

Inherited fromInherited from

GenericGroupEntity.constructor

PropertiesProperties

childrenchildren

readonly children: readonly GenericEntity<unknown, {}, GenericRootEntity<unknown, {}>>[]

Inherited fromInherited from

GenericGroupEntity.children

AccessorsAccessors

parentparent

get parent(): null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Get parent entity.

ReturnsReturns

null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Inherited fromInherited from

GenericGroupEntity.parent

---

rootroot

get root(): this

Get root entity.

ReturnsReturns

this

OverridesOverrides

GenericGroupEntity.root

MethodsMethods

addChildaddChild

addChild(child, index?): GenericRootEntity<Props, DefaultProps>

ParametersParameters

Name	Type
child	GenericEntity<unknown, {}, GenericRootEntity<unknown, {}>>
index?	number

ReturnsReturns

GenericRootEntity<Props, DefaultProps>

Inherited fromInherited from

GenericGroupEntity.addChild

---

destroydestroy

Abstract destroy(): void

Completely destroys the entity tree including the current entity

ReturnsReturns

void

---

removeChildremoveChild

removeChild(child): GenericRootEntity<Props, DefaultProps>

ParametersParameters

Name	Type
child	GenericEntity<unknown, {}, GenericRootEntity<unknown, {}>>

ReturnsReturns

GenericRootEntity<Props, DefaultProps>

Inherited fromInherited from

GenericGroupEntity.removeChild

---

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<Props>	New props values.

ReturnsReturns

void

Inherited fromInherited from

GenericGroupEntity.update

Class: MMapClass: MMap

Main API class. Create a map container.

Example

const map = new MMap(
    document.getElementById('map-root'),
    {location: {center: [-0.118092, 51.509865], zoom: 10}}
);
// add default Mappable scheme layer
map.addChild(new MMapDefaultSchemeLayer());
// relocate map to another point with animation in 200 milliseconds
map.setLocation({center: [48.707067, 44.516975], duration: 200});
// change mode from default `auto` to `raster`
map.setMode('raster');
// get map zoom for some calculations
const zoom = map.zoom;

ConstructorsConstructors

constructorconstructor

new MMap(rootContainer, props, children?)

ParametersParameters

Name	Type
rootContainer	HTMLElement
props	MMapProps
children?	MMapEntity<unknown, {}>[]

OverridesOverrides

GenericRootEntity.constructor

PropertiesProperties

childrenchildren

readonly children: MMapEntity<unknown, {}>[]

OverridesOverrides

GenericRootEntity.children

---

[overrideKeyReactify][overrideKeyReactify]

static [overrideKeyReactify]: CustomReactify<MMap, ForwardRefExoticComponent<{
	behaviors?: BehaviorType[];
	camera?: MMapCameraRequest;
	children?: ReactNode;
	className?: string;
	config?: Config;
	copyrights?: boolean;
	copyrightsPosition?: MMapCopyrightsPosition;
	hotspotsStrategy?: "forViewport" | "forPointerPosition";
	key?: null | Key;
	location: MMapLocationRequest;
	margin?: Margin;
	mode?: MapMode;
	projection?: Projection;
	ref?: Ref<MMap>;
	restrictMapArea?: false | LngLatBounds;
	showScaleInCopyrights?: boolean;
	theme?: MMapTheme;
	tiltRange?: TiltRange;
	worldOptions?: WorldOptions;
	zoomRange?: ZoomRange;
	zoomRounding?: ZoomRounding;
	zoomStrategy?: ZoomStrategy 
}>>

---

defaultPropsdefaultProps

static defaultProps: Readonly<{
	behaviors: string[];
	camera: {
		azimuth: number;
		tilt: number 
	};
	className: "";
	config: Config;
	copyrights: true;
	copyrightsPosition: "bottom right";
	hotspotsStrategy: "forViewport" | "forPointerPosition";
	margin: undefined | Margin;
	mode: "auto";
	projection: Projection;
	restrictMapArea: false;
	showScaleInCopyrights: false;
	theme: "light";
	worldOptions: {
		cycledX: boolean;
		cycledY: boolean 
	};
	zoomRange: ZoomRange;
	zoomRounding: "auto";
	zoomStrategy: "zoomToPointer" 
}>

AccessorsAccessors

azimuthazimuth

get azimuth(): number

ReturnsReturns

number

---

behaviorsbehaviors

get behaviors(): readonly BehaviorType[]

getter for MMapProps.behaviors prop

ReturnsReturns

readonly BehaviorType[]

---

boundsbounds

get bounds(): LngLatBounds

getter for MMapProps.location.bounds prop

ReturnsReturns

LngLatBounds

---

centercenter

get center(): readonly [number, number, undefined | number]

getter for MMapProps.location.center prop

ReturnsReturns

readonly [number, number, undefined | number]

---

configconfig

get config(): Readonly<Config>

getter for MMapProps.config prop

ReturnsReturns

Readonly<Config>

---

containercontainer

get container(): HTMLElement

Main map container

ReturnsReturns

HTMLElement

---

parentparent

get parent(): null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Get parent entity.

ReturnsReturns

null | GenericComplexEntity<unknown, {}, GenericRootEntity<unknown, {}>>

Inherited fromInherited from

GenericRootEntity.parent

---

projectionprojection

get projection(): Projection

getter for MMapProps.projection prop

ReturnsReturns

Projection

---

restrictMapArearestrictMapArea

get restrictMapArea(): Readonly<false | LngLatBounds>

getter for MMapProps.restrictMapArea prop

ReturnsReturns

Readonly<false | LngLatBounds>

---

rootroot

get root(): this

Get root entity.

ReturnsReturns

this

Inherited fromInherited from

GenericRootEntity.root

---

sizesize

get size(): PixelCoordinates

getter for map size

ReturnsReturns

PixelCoordinates

---

themetheme

get theme(): "dark" | "light"

getter for MMapProps.theme prop

ReturnsReturns

"dark" | "light"

---

tilttilt

get tilt(): number

ReturnsReturns

number

---

tiltRangetiltRange

get tiltRange(): Readonly<TiltRange>

ReturnsReturns

Readonly<TiltRange>

---

zoomzoom

get zoom(): number

getter for MMapProps.location.zoom prop

ReturnsReturns

number

---

zoomRangezoomRange

get zoomRange(): Readonly<ZoomRange>

getter for MMapProps.zoomRange prop

ReturnsReturns

Readonly<ZoomRange>

MethodsMethods

addChildaddChild

addChild(child, index?): MMap

ParametersParameters

Name	Type
child	MMapEntity<unknown, {}>
index?	number

ReturnsReturns

MMap

OverridesOverrides

GenericRootEntity.addChild

---

destroydestroy

destroy(): void

Destroy map and remove it from user DOM-element

ReturnsReturns

void

OverridesOverrides

GenericRootEntity.destroy

---

removeChildremoveChild

removeChild(child): MMap

ParametersParameters

Name	Type
child	MMapEntity<unknown, {}>

ReturnsReturns

MMap

OverridesOverrides

GenericRootEntity.removeChild

---

setBehaviorssetBehaviors

setBehaviors(behaviors): void

setter for MMapProps.behaviors prop

ParametersParameters

Name	Type
behaviors	BehaviorType[]

ReturnsReturns

void

---

setCamerasetCamera

setCamera(camera): void

setter for MMapProps.camera prop

ParametersParameters

Name	Type
camera	MMapCameraRequest

ReturnsReturns

void

---

setConfigsetConfig

setConfig(config): void

setter for MMapProps.config prop

ParametersParameters

Name	Type
config	Config

ReturnsReturns

void

---

setLocationsetLocation

setLocation(location): void

setter for MMapProps.location prop

ParametersParameters

Name	Type
location	MMapLocationRequest

ReturnsReturns

void

---

setMarginsetMargin

setMargin(margin): void

setter for MMapProps.margin prop

ParametersParameters

Name	Type
margin	Margin

ReturnsReturns

void

---

setModesetMode

setMode(mode): void

setter for MMapProps.mode prop

ParametersParameters

Name	Type
mode	MapMode

ReturnsReturns

void

---

setProjectionsetProjection

setProjection(projection): void

setter for MMapProps.projection prop

ParametersParameters

Name	Type
projection	Projection

ReturnsReturns

void

---

setRestrictMapAreasetRestrictMapArea

setRestrictMapArea(restrictMapArea): void

setter for MMapProps.config prop

ParametersParameters

Name	Type
restrictMapArea	LngLatBounds

ReturnsReturns

void

---

setZoomRangesetZoomRange

setZoomRange(zoomRange): void

setter for MMapProps.zoomRange prop

ParametersParameters

Name	Type
zoomRange	ZoomRange

ReturnsReturns

void

---

setZoomRoundingsetZoomRounding

setZoomRounding(zoomRounding): void

setter for MMapProps.zoomRounding prop

ParametersParameters

Name	Type
zoomRounding	ZoomRounding

ReturnsReturns

void

---

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<MMapProps>	New props values.

ReturnsReturns

void

Inherited fromInherited from

GenericRootEntity.update

Class: MMapComplexEntity<Props, DefaultPropsClass: MMapComplexEntity<Props, DefaultProps>

Entity that aggregates multiple Entities but looks basic from the outside.

Type Param

Root Entity Class.

Example

type MMapSomeComplexEntityProps = {
 name?: string;
};
const defaultProps = {
 name: 'entity'
};
class MMapSomeComplexEntity extends MMapComplexEntity<MMapSomeComplexEntityProps, typeof defaultProps> {
 static defaultProps = defaultProps;
 private _someEntity?: MMapSomeEntity; // MMapSomeEntity extends GenericEntity
 protected _onAttach(): void {
     this._someEntity = new MMapSomeEntity();
     this.addChild(this._someEntity); // add someEntity as children
     // ...
 }
 // ...
}

Type parametersType parameters

Name	Type	Description
Props	Props	Type of input props of the Entity.
DefaultProps	extends Object = {}	Type of default input props of the Entity.

ImplementsImplements

• MMapEntity<Props, DefaultProps>

ConstructorsConstructors

constructorconstructor

new MMapComplexEntity<Props, DefaultProps>(props, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}

ParametersParameters

Name	Type	Description
props	Props	The value of input props.
options?	ComplexOptions<MMap>	Optional options object.

Inherited fromInherited from

GenericComplexEntity.constructor

new MMapComplexEntity<Props, DefaultProps>(props, children?, options?)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}

ParametersParameters

Name	Type
props	Props
children?	GenericEntity<unknown, {}, MMap>[]
options?	Omit<ComplexOptions<MMap>, "children">

Inherited fromInherited from

GenericComplexEntity.constructor

AccessorsAccessors

parentparent

get parent(): null | MMapComplexEntity<unknown, {}>

Get parent entity.

ReturnsReturns

null | MMapComplexEntity<unknown, {}>

Implementation ofImplementation of

MMapEntity.parent

OverridesOverrides

GenericComplexEntity.parent

---

rootroot

get root(): null | MMap

Get root entity.

ReturnsReturns

null | MMap

Implementation ofImplementation of

MMapEntity.root

OverridesOverrides

GenericComplexEntity.root

MethodsMethods

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<Props>	New props values.

ReturnsReturns

void

Implementation ofImplementation of

MMapEntity.update

Inherited fromInherited from

GenericComplexEntity.update

Class: MMapEntity<Props, DefaultPropsClass: MMapEntity<Props, DefaultProps>

Entity Base Class. It has event handlers for attaching, detaching and updating props. Has a method for providing and using context.

Example

type MMapSomeEntityProps = {
 name?: string;
};
const defaultProps = {
 name: 'entity'
};
class MMapSomeEntity extends MMapEntity<MMapSomeEntityProps, typeof defaultProps> {
 static defaultProps = defaultProps;
 public isAttached: boolean;
 constructor(props: MMapSomeEntityProps) {
     super(props);
     this.isAttached = false
     // Additional actions can be taken in the constructor of a class.
 }
 protected _onAttach(): void {
     this.isAttached = true;
     // Additional actions can be taken when an Entity is attached.
 }
 // ...
}

Type parametersType parameters

Name	Type	Description
Props	Props	Type of input props of the Entity.
DefaultProps	extends Object = {}	Type of default input props of the Entity.

Implemented byImplemented by

• MMapComplexEntity

ConstructorsConstructors

constructorconstructor

new MMapEntity<Props, DefaultProps>(props)

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Object = {}

ParametersParameters

Name	Type	Description
props	Props	The value of input props.

Inherited fromInherited from

GenericEntity.constructor

AccessorsAccessors

parentparent

get parent(): null | MMapComplexEntity<unknown, {}>

Get parent entity.

ReturnsReturns

null | MMapComplexEntity<unknown, {}>

OverridesOverrides

GenericEntity.parent

---

rootroot

get root(): null | MMap

Get root entity.

ReturnsReturns

null | MMap

OverridesOverrides

GenericEntity.root

MethodsMethods

updateupdate

update(changedProps): void

Method for updating props of Entity.

ParametersParameters

Name	Type	Description
changedProps	Partial<Props>	New props values.

ReturnsReturns

void

Inherited fromInherited from

GenericEntity.update

Interface: ApikeysInterface: Apikeys

All possible apikeys for http-services.

PropertiesProperties

routerrouter

optional router: string

---

searchsearch

optional search: string

---

suggestsuggest

optional suggest: string

Interface: BlockingPropsInterface: BlockingProps

PropertiesProperties

blockBehaviorsblockBehaviors

optional blockBehaviors: boolean

This parameter block all map behaviors for the element.
The element itself can be zoomed and scrolled by mouse and gestures.
The map will no longer be able to respond to any BehaviorType on this element (except dblClick).
Double clicks and other map events will be blocked by the blockEvents parameter.

---

blockEventsblockEvents

optional blockEvents: boolean

This parameter block all map events for the element.
The map will no longer be able to respond to any DomEvents on this element, including clicks, double-clicks and others.

Interface: ComplexOptions<RootInterface: ComplexOptions<Root>

Type parametersType parameters

Name	Type
Root	extends GenericRootEntity<unknown> = GenericRootEntity<unknown>

PropertiesProperties

childrenchildren

optional children: GenericEntity<unknown, {}, Root>[]

---

containercontainer

optional container: boolean

Interface: DraggableProps<CallbackInterface: DraggableProps<Callback>

Type parametersType parameters

Name
Callback

PropertiesProperties

draggabledraggable

optional draggable: boolean

Feature can be draggable

---

mapFollowsOnDragmapFollowsOnDrag

optional mapFollowsOnDrag: boolean | {
	activeZoneMargin?: Margin 
}

Will map center follows marker on drag if marker near the edge of the map

---

onDragEndonDragEnd

optional onDragEnd: Callback

May be a function that will be called when the user drags and drops an element to a new location on the map.
The arguments to the function will include the new coordinates.
A component that uses this component should immediately save the new coordinates in its state and then use
the new coordinates as props for the marker.

---

onDragMoveonDragMove

optional onDragMove: Callback

Fires on drag move

---

onDragStartonDragStart

optional onDragStart: Callback

Fires on drag start

Interface: FeatureClickEventsInterface: FeatureClickEvents

PropertiesProperties

onClickonClick

optional onClick: (`event`: MouseEvent, `mapEvent`: MapEvent) => void

Type declarationType declaration

(event, mapEvent): void

Click handler

ParametersParameters

Name	Type
event	MouseEvent
mapEvent	MapEvent

ReturnsReturns

void

---

onDoubleClickonDoubleClick

optional onDoubleClick: (`event`: MouseEvent, `mapEvent`: MapEvent) => void

Type declarationType declaration

(event, mapEvent): void

Double click handler

ParametersParameters

Name	Type
event	MouseEvent
mapEvent	MapEvent

ReturnsReturns

void

---

onFastClickonFastClick

optional onFastClick: (`event`: MouseEvent, `mapEvent`: MapEvent) => void

Type declarationType declaration

(event, mapEvent): void

Fast click handler

ParametersParameters

Name	Type
event	MouseEvent
mapEvent	MapEvent

ReturnsReturns

void

Interface: GenericProjection<TSourceInterface: GenericProjection<TSource>

Type parametersType parameters

Name
TSource

PropertiesProperties

typetype

optional readonly type: string

Projection identity type. It may be:

• EPSG-code (e.g. EPSG:3857)
• any other string to identify (e.g. 'cartesian')

MethodsMethods

fromWorldCoordinatesfromWorldCoordinates

fromWorldCoordinates(coordinates): TSource

ParametersParameters

Name	Type
coordinates	WorldCoordinates

ReturnsReturns

TSource

---

toWorldCoordinatestoWorldCoordinates

toWorldCoordinates(point): WorldCoordinates

ParametersParameters

Name	Type
point	TSource

ReturnsReturns

WorldCoordinates

Interface: MapEventInterface: MapEvent

PropertiesProperties

coordinatescoordinates

coordinates: LngLat

---

screenCoordinatesscreenCoordinates

screenCoordinates: [number, number]

[x, y]

---

stopPropagationstopPropagation

stopPropagation: () => void

Type declarationType declaration

(): void

ReturnsReturns

void

Interface: PixelCoordinatesInterface: PixelCoordinates

Global pixel coordinates. World size depends on zoom.
Left top is (0; 0).
Right bottom is (2**(zoom + 8); 2**(zoom + 8)).

PropertiesProperties

typetype

optional readonly type: "pixel"

---

xx

x: number

Inherited fromInherited from

Vec2.x

---

yy

y: number

Inherited fromInherited from

Vec2.y

Interface: ReactParentInterface: ReactParent

PropertiesProperties

entityRefentityRef

entityRef: RefInstance<GenericEntity<unknown, {}, GenericRootEntity<unknown, {}>>>

MethodsMethods

positionChildpositionChild

positionChild(entity): number

ParametersParameters

Name	Type
entity	RefInstance<GenericEntity<unknown, {}, GenericRootEntity<unknown, {}>>>

ReturnsReturns

number

---

requestRepositionrequestReposition

requestReposition(): void

ReturnsReturns

void

Interface: TiltRangeInterface: TiltRange

PropertiesProperties

expansionexpansion

readonly expansion: number

Behavior tilt expansion in radians. E.g. you can tilt map with fingers a little bit more than max.

---

maxmax

readonly max: number

Maximum tilt in radians.

---

minmin

readonly min: number

Minimum tilt in radians.

Interface: Vec2Interface: Vec2

PropertiesProperties

xx

x: number

---

yy

y: number

Interface: VuefyModuleFnInterface: VuefyModuleFn

CallableCallable

VuefyModuleFnVuefyModuleFn

VuefyModuleFn<TModule>(module, props?): VuefiedModule<TModule>

Type parametersType parameters

Name	Type
TModule	extends BaseModule = BaseModule

ParametersParameters

Name	Type
module	TModule
props?	VuefyPropsModule<TModule>

ReturnsReturns

VuefiedModule<TModule>

Interface: WorldCoordinatesInterface: WorldCoordinates

Coordinates in [-1 ... +1].
Left bottom is (-1; -1).
Right top is (+1; +1).
Center is (0; 0).

PropertiesProperties

typetype

optional readonly type: "world"

---

xx

x: number

Inherited fromInherited from

Vec2.x

---

yy

y: number

Inherited fromInherited from

Vec2.y

---

zz

optional z: number

Interface: WorldOptionsInterface: WorldOptions

PropertiesProperties

cycledXcycledX

readonly cycledX: boolean

Interface: ZoomRangeInterface: ZoomRange

PropertiesProperties

maxmax

max: number

---

minmin

min: number

Type AliasesType Aliases

MMapDefaultMarkerPropsMMapDefaultMarkerProps

MMapDefaultMarkerProps: MMapMarkerProps & DefaultMarkerCustomProps

MMapDefaultMarker props

Module: <internalModule: <internal>

Type AliasesType Aliases

BaseModuleBaseModule

BaseModule: Record<string | symbol, unknown>

---

BehaviorTypeBehaviorType

BehaviorType: "drag" | "pinchZoom" | "scrollZoom" | "dblClick" | "magnifier" | "oneFingerZoom" | "mouseRotate" | "mouseTilt" | "pinchRotate" | "panTilt"

---

ContextWatcherFnContextWatcherFn

ContextWatcherFn: () => void

Type declarationType declaration

(): void

ReturnsReturns

void

---

CustomReactifyCustomReactify

CustomReactify<TEntity,
 TResult\>: (`ctor`: EntityConstructor<TEntity>, `params`: {
	React: typeof TReact;
	ReactDOM: typeof TReactDOM;
	ReactParent: typeof ReactParent;
	reactify: {
		context: <TContext>(`context?`: TContext) => TReact.Context<unknown>;
		module: ReactifyModule;
		entity: <T>(...`args`: [ctor: T, displayName?: string]) => T extends Overrided<T, TResult> ? TResult : ForwardRefExoticComponent<PropsWithoutRef<PropsWithChildren<EntityProps<InstanceType<T>>>> & RefAttributes<undefined | InstanceType<T>>> 
	} 
}) => TResult

Type parametersType parameters

Name	Type
TEntity	extends GenericEntity<unknown>
TResult	TResult

Type declarationType declaration

(ctor, params): TResult

ParametersParameters

Name	Type
ctor	EntityConstructor<TEntity>
params	Object
params.React	typeof TReact
params.ReactDOM	typeof TReactDOM
params.ReactParent	typeof ReactParent
params.reactify	Object
params.reactify.context	<TContext>(context?: TContext) => TReact.Context<unknown>
params.reactify.module	ReactifyModule
params.reactify.entity	<T>(...args: [ctor: T, displayName?: string]) => T extends Overrided<T, TResult> ? TResult : ForwardRefExoticComponent<PropsWithoutRef<PropsWithChildren<EntityProps<InstanceType<T>>>> & RefAttributes<undefined | InstanceType<T>>>

ReturnsReturns

TResult

---

CustomVuefyFnCustomVuefyFn

CustomVuefyFn<TEntity,
 TExternalProps\>: (`ctor`: EntityConstructor<TEntity>, `props`: VuefyPropsObject<TExternalProps>, `params`: {
	Vue: typeof TVue;
	vuefy: {
		context: VuefyContextFn;
		entity: VuefyEntityFn;
		module: VuefyModuleFn 
	} 
}) => TVue.Component<TExternalProps>

Type parametersType parameters

Name	Type
TEntity	extends DefaultEntity
TExternalProps	EntityProps<TEntity>

Type declarationType declaration

(ctor, props, params): TVue.Component<TExternalProps>

ParametersParameters

Name	Type
ctor	EntityConstructor<TEntity>
props	VuefyPropsObject<TExternalProps>
params	Object
params.Vue	typeof TVue
params.vuefy	Object
params.vuefy.context	VuefyContextFn
params.vuefy.entity	VuefyEntityFn
params.vuefy.module	VuefyModuleFn

ReturnsReturns

TVue.Component<TExternalProps>

---

CustomVuefyOptionsCustomVuefyOptions

CustomVuefyOptions<TEntity,
 TExternalProps\>: Object

Type parametersType parameters

Name	Type
TEntity	extends DefaultEntity
TExternalProps	EntityProps<TEntity>

Type declarationType declaration

Name	Type
props	VuefyPropsObject<TExternalProps> | VuefyPropsArray<TExternalProps>

---

DefaultContextDefaultContext

DefaultContext: Context<unknown>

---

DefaultCtorDefaultCtor

DefaultCtor: EntityConstructor<DefaultEntity>

---

DefaultEntityDefaultEntity

DefaultEntity: GenericEntity<unknown>

---

DefaultMarkerCustomPropsDefaultMarkerCustomProps

DefaultMarkerCustomProps: Object

Type declarationType declaration

Name	Type	Description
color?	string	Marker icon color
popup?	{ content: string | (close: () => void) => HTMLElement ; hidesMarker?: boolean ; position: "left" | "right" | "top" }	Popup
popup.content	string | (close: () => void) => HTMLElement	Popup content
popup.hidesMarker?	boolean	Should popup hide marker. Default is false
popup.position	"left" | "right" | "top"	Popup position
subtitle?	string	Marker subtitle HTML
title?	string	Marker title HTML

---

DefaultPropsDefaultProps

DefaultProps: typeof defaultProps

---

DefaultPropsDefaultProps

DefaultProps: typeof defaultProps

---

EasingBezierPresetEasingBezierPreset

EasingBezierPreset: Object

Type declarationType declaration

Name	Type
p1	Vec2
p2	Vec2

---

EasingFunctionEasingFunction

EasingFunction: (`x`: number) => number

Type declarationType declaration

(x): number

ParametersParameters

Name	Type
x	number

ReturnsReturns

number

---

EasingFunctionDescriptionEasingFunctionDescription

EasingFunctionDescription: EasingPresetName | EasingBezierPreset | EasingFunction

---

EasingPresetNameEasingPresetName

EasingPresetName: "linear" | "ease" | "ease-in" | "ease-out" | "ease-in-out"

---

EntityConstructorEntityConstructor

EntityConstructor<TEntity\>: (...`args`: any[]) => TEntity

Type parametersType parameters

Name	Type
TEntity	extends GenericEntity<unknown>

Type declarationType declaration

(...args)

ParametersParameters

Name	Type
...args	any[]

---

EntityPropsEntityProps

EntityProps<T\>: T extends GenericEntity<infer P> ? P : never

Type parametersType parameters

Name	Type
T	extends GenericEntity<unknown>

---

GenericBoundsGenericBounds

GenericBounds<T\>: [T, T]

Generic for rectangle bounded by bottom-left and top-right coordinates

Type parametersType parameters

Name
T

---

HideOutsideRuleHideOutsideRule

HideOutsideRule: {
	extent: number 
} | boolean

---

LngLatLngLat

LngLat: [lon: number, lat: number, alt?: number]

Tuple with geodesic coordinates in longitude latitude order.
GeoJSON also uses this order https://tools.ietf.org/html/rfc7946#appendix-A.1

---

LngLatBoundsLngLatBounds

LngLatBounds: GenericBounds<LngLat>

Rectangle bounded by top-left and bottom-right coordinates

---

MMapBoundsLocationMMapBoundsLocation

MMapBoundsLocation: Object

Calculate the center and zoom by specifying the coordinates of the top left and bottom right corners of the map.
In this case, the center of the map will be in the center of the rectangle described at the given coordinates.
If the map have an aspect ratio different from this rectangle, the rectangle will be inscribed in height and the map will be centered in width.

map.update({
    location: {bounds: [[-0.118092, 51.509865], [-0.118092, 51.509865]]}
});

Type declarationType declaration

Name	Type
bounds	LngLatBounds

---

MMapCameraMMapCamera

MMapCamera: Object

Observer camera position

Type declarationType declaration

Name	Type	Description
azimuth?	number	Map rotation in radians. Can take values from -Math.PI to Math.PI
tilt?	number	Map tilt in radians. Can take values from 0 to 50 degrees (degrees * (Math.PI / 180))

---

MMapCameraRequestMMapCameraRequest

MMapCameraRequest: MMapCamera & {
	duration?: number;
	easing?: EasingFunctionDescription 
}

Describes how to change current camera position. Change can be instantaneous or animated if duration property is set.

map.update({camera: {
     tilt: 45 * (Math.PI / 180), // 45 degrees
     azimuth: 30 * (Math.PI / 180) // 30 degrees
     duration: 200, // Animation of moving camera will take 200 milliseconds
     easing: 'ease-in-out'
 }});

---

MMapCenterLocationMMapCenterLocation

MMapCenterLocation: Object

Sets map center. In this case, the zoom of the map remains unchanged.

map.update({
  location: {center: [-0.118092, 51.509865]}
});

Type declarationType declaration

Name	Type
center	LngLat

---

MMapCenterZoomLocationMMapCenterZoomLocation

MMapCenterZoomLocation: MMapCenterLocation & MMapZoomLocation

Sets map center and zoom. Combination of MMapCenterLocation and MMapZoomLocation

map.update({
 location: {center: [-0.118092, 51.509865], zoom: 10}
});

---

MMapCopyrightsPositionMMapCopyrightsPosition

MMapCopyrightsPosition: "top left" | "top right" | "bottom left" | "bottom right"

Copyrights position on the map container. By default, 'bottom right'.
For example, 'top left' or 'bottom right'

const map = new mappable.MMap(document.getElementById('map-root'), {
 copyrightsPosition: 'top left'
});

---

MMapLocationRequestMMapLocationRequest

MMapLocationRequest: MMapBoundsLocation | MMapCenterLocation | MMapZoomLocation | MMapCenterZoomLocation & {
	duration?: number;
	easing?: EasingFunctionDescription 
}

Describes how to change current map location. Change can be instantaneous or animated if duration property is set.

map.update({
 location: {
     center: [-0.118092, 51.509865], // Center of the map
     zoom: 10, // Zoom level
     duration: 200, // Animation of moving map will take 200 milliseconds
     easing: 'ease-in-out' // Animation easing function
 }
});

or just change center of the map

map.update({
 location: {
    center: [-0.118092, 51.509865], // Center of the map
    duration: 200, // Animation of moving map will take 200 milliseconds
    easing: 'linear' // Animation easing function
 }
})';

---

MMapMarkerEventHandlerMMapMarkerEventHandler

MMapMarkerEventHandler: (`coordinates`: LngLat) => void | false

Type declarationType declaration

(coordinates): void | false

MMapMarker events handler

ParametersParameters

Name	Type
coordinates	LngLat

ReturnsReturns

void | false

---

MMapMarkerPropsMMapMarkerProps

MMapMarkerProps: {
	coordinates: LngLat;
	disableRoundCoordinates?: boolean;
	hideOutsideViewport?: HideOutsideRule;
	id?: string;
	properties?: Record<string, unknown>;
	source?: string;
	zIndex?: number 
} & DraggableProps<MMapMarkerEventHandler> & BlockingProps & FeatureClickEvents

MMapMarker props

---

MMapPropsMMapProps

MMapProps: Object

Map settings. Allow to set map mode, behaviors, margin, zoom rounding, zoom range, restrict map area, theme and other settings.

const map = new MMap(document.getElementById('map-root'), {
   className: 'custom-map',
   location: {center: [-0.118092, 51.509865], zoom: 10},
   camera: {tilt: 45 * (Math.PI / 180), azimuth: 30 * (Math.PI / 180)}
   mode: 'raster',
   behaviors: ['drag', 'scrollZoom', 'dblClick', 'mouseRotate', 'mouseTilt'],
   margin: [0, 100, 0, 0],
   theme: 'light'
});

But required only location prop.

const map = new MMap(document.getElementById('map-root'), {
  location: {center: [-0.118092, 51.509865], zoom: 10}
});

Type declarationType declaration

Name	Type	Description
behaviors?	BehaviorType[]	Active behaviors
camera?	MMapCameraRequest	Initial camera or request to change camera with duration
className?	string	Map container css class name
config?	Config	Other configs
copyrightsPosition?	MMapCopyrightsPosition	Position of copyright on the page. Default is 'bottom right'
hotspotsStrategy?	"forViewport" | "forPointerPosition"	Strategy for fetching hotspots, for whole viewport or for tiles that pointer is hovering at
location	MMapLocationRequest	Initial location or request to change location with duration
margin?	Margin	Map margins
mode?	MapMode	Map mode, 'auto' (default. Show raster tiles while vector tiles are loading), 'raster' or 'vector' (without raster preloading).
projection?	Projection	Projection used in map
restrictMapArea?	LngLatBounds | false	Sets the map view area so that the user cannot move outside of this area.
showScaleInCopyrights?	boolean	Show the map scale next to copyright
theme?	MMapTheme	Theme applied to the scheme
worldOptions?	WorldOptions	Whether to repeat the world in X and Y
zoomRange?	ZoomRange	Restrict min and max map zoom
zoomRounding?	ZoomRounding	Set rounding for zoom. If auto is selected, zoom will be snap for raster and smooth for vector MapMode. Default is auto.
zoomStrategy?	ZoomStrategy	Zoom strategy describes if map center is bound to the zoom point or not

---

MMapThemeMMapTheme

MMapTheme: "light" | "dark"

Map theme. Affects the colors of the map controls and background.

const map = new mappable.MMap({
   location: {center: [55.751574, 37.573856], zoom: 9},
   theme: 'dark'
});

---

MMapZoomLocationMMapZoomLocation

MMapZoomLocation: Object

Sets map zoom. In this case, the center of the map remains unchanged.

map.update({
   location: {zoom: 10}
});

Type declarationType declaration

Name	Type
zoom	number

---

MapModeMapMode

MapMode: "raster" | "vector" | "auto"

---

MarginMargin

Margin: [number, number, number, number]

Map margins in pixels. Order is top, right, bottom, left.

---

OverridedOverrided

Overrided<TCtor,
 TReactResult\>: Object

Type parametersType parameters

Name	Type
TCtor	extends EntityConstructor<GenericEntity<unknown>>
TReactResult	TReactResult

Type declarationType declaration

Name	Type
[overrideKeyReactify]	CustomReactify<InstanceType<TCtor>, TReactResult>

---

ProjectionProjection

Projection: GenericProjection<LngLat>

---

PropsFromCtorPropsFromCtor

PropsFromCtor<TCtor\>: EntityProps<InstanceType<TCtor>>

Type parametersType parameters

Name	Type
TCtor	extends DefaultCtor

---

RefInstanceRefInstance

RefInstance<TEntity\>: React.MutableRefObject<TEntity | undefined>

Type parametersType parameters

Name	Type
TEntity	extends GenericEntity<unknown>

---

VuefiedModuleVuefiedModule

VuefiedModule<TModule\>: { [Property in keyof TModule]: TModule[Property] extends DefaultCtor ? ReturnType<VuefyEntityFnGen<TModule[Property]\>\> : TModule[Property] extends typeof Context ? ReturnType<VuefyContextFn\> : TModule[Property] }

Type parametersType parameters

Name	Type
TModule	extends BaseModule

---

VuefyContextFnVuefyContextFn

VuefyContextFn: <TContext>(`context?`: TContext) => symbol

Type declarationType declaration

<TContext>(context?): symbol

Type parametersType parameters

Name	Type
TContext	extends DefaultContext

ParametersParameters

Name	Type
context?	TContext

ReturnsReturns

symbol

---

VuefyEntityFnVuefyEntityFn

VuefyEntityFn: <TCtor, TProps>(...`args`: Parameters<VuefyEntityFnGen<TCtor, TProps>>) => ReturnType<VuefyEntityFnGen<TCtor, TProps>>

Type declarationType declaration

<TCtor, TProps>(...args): ReturnType<VuefyEntityFnGen<TCtor, TProps>>

Type parametersType parameters

Name	Type
TCtor	extends DefaultCtor
TProps	PropsFromCtor<TCtor>

ParametersParameters

Name	Type
...args	Parameters<VuefyEntityFnGen<TCtor, TProps>>

ReturnsReturns

ReturnType<VuefyEntityFnGen<TCtor, TProps>>

---

VuefyEntityFnGenVuefyEntityFnGen

VuefyEntityFnGen<TCtor,
 TProps\>: (`ctor`: TCtor, `props?`: VuefyPropsObject<TProps> | VuefyPropsArray<TProps>, `displayName?`: string) => TVue.Component<TProps>

Type parametersType parameters

Name	Type
TCtor	extends DefaultCtor
TProps	PropsFromCtor<TCtor>

Type declarationType declaration

(ctor, props?, displayName?): TVue.Component<TProps>

ParametersParameters

Name	Type
ctor	TCtor
props?	VuefyPropsObject<TProps> | VuefyPropsArray<TProps>
displayName?	string

ReturnsReturns

TVue.Component<TProps>

---

VuefyPropsArrayVuefyPropsArray

VuefyPropsArray<RawProps\>: keyof RawProps[]

Type parametersType parameters

Name
RawProps

---

VuefyPropsModuleVuefyPropsModule

VuefyPropsModule<TModule\>: { [Key in keyof TModule]: TModule[Key] extends GenericEntity<infer Props\> ? VuefyPropsObject<Props\> \| VuefyPropsArray<Props\> : unknown }

Type parametersType parameters

Name	Type
TModule	extends BaseModule

---

VuefyPropsObjectVuefyPropsObject

VuefyPropsObject<RawProps\>: { [K in keyof RawProps]-?: TVue.PropType<RawProps[K]\> \| TVue.Prop<RawProps[K]\> }

Type parametersType parameters

Name
RawProps

---

WithDefaultsWithDefaults

WithDefaults<Props,
 DefaultProps\>: Props & { [K in keyof DefaultProps]: K extends keyof Props ? NonNullable<Props[K]\> : never }

Type parametersType parameters

Name	Type
Props	Props
DefaultProps	extends Partial<Props>

---

ZoomRoundingZoomRounding

ZoomRounding: "snap" | "smooth" | "auto"

Set rounding for zoom.
If auto is selected, zoom will be snap for raster and smooth for vector MapMode.
Default is auto.

---

ZoomStrategyZoomStrategy

ZoomStrategy: "zoomToCenter" | "zoomToPointer"

VariablesVariables

ReactParentReactParent

ReactParent: React.Context<[ReactParent] | undefined>

---

ReactParentReactParent

ReactParent: Context<undefined | [ReactParent]>

---

defaultPropsdefaultProps

const defaultProps: Readonly<{
	color: "#f33";
	hideOutsideViewport: true 
}>

---

defaultPropsdefaultProps

const defaultProps: Readonly<{
	behaviors: string[];
	camera: {
		azimuth: number;
		tilt: number 
	};
	className: "";
	config: Config;
	copyrights: true;
	copyrightsPosition: "bottom right";
	hotspotsStrategy: "forViewport" | "forPointerPosition";
	margin: Margin | undefined;
	mode: "auto";
	projection: Projection;
	restrictMapArea: false;
	showScaleInCopyrights: false;
	theme: "light";
	worldOptions: {
		cycledX: boolean;
		cycledY: boolean 
	};
	zoomRange: ZoomRange;
	zoomRounding: "auto";
	zoomStrategy: "zoomToPointer" 
}>