Class AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS, CFG>`Abstract`

Base class for the map modules that add and own their own GeoJSON sources, layers and images: places, routes, geometries, the traffic overlays and bring-your-own-data.

Remarks

The module owns the data it draws. Its generated IDs therefore carry a per-instance suffix (see instanceIndex), and the module is safely multi-instance: every create(map, config?) call returns another module with its own sources and layers.

Owning the data brings the duty this class states: a clean style switch must forget the data the module remembers having shown, through discardShownData.

Every such module hides and shows through setVisible, which keeps the data it shows.

Owning the features also lets it read and write their event states: putEventState, cleanEventState, cleanEventStates and getEventStates act on the features its show takes, and each named scope of its events carries the same four over its own part (UserEventsWithStates). A style change shows again what its sources draw, not the data show was given, so the states survive it.

Type Parameters

SOURCES_WITH_LAYERS extends GeoJSONSourcesWithLayers
The GeoJSON sources, with their layers, this module owns
CFG extends MapModuleCommonConfig & { visible?: boolean } | undefined = undefined
The configuration type for this module, or undefined if no configuration is needed

Hierarchy (View Summary)

AbstractMapModule<SOURCES_WITH_LAYERS, CFG>
- AbstractDataOwnedMapModule

Index

Constructors

`Protected`constructor

new AbstractDataOwnedMapModule<
    SOURCES_WITH_LAYERS extends GeoJSONSourcesWithLayers,
    CFG extends
        MapModuleCommonConfig & { visible?: boolean } | undefined = undefined,
>(
    tomtomMap: TomTomMap,
    config?: CFG,
): AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS, CFG>
Builds this module based on a given Maps SDK map.
Type Parameters
- SOURCES_WITH_LAYERS extends GeoJSONSourcesWithLayers
  The GeoJSON sources, with their layers, this module owns
- CFG extends MapModuleCommonConfig & { visible?: boolean } | undefined = undefined
  The configuration type for this module, or undefined if no configuration is needed
Parameters
- tomtomMap: TomTomMap
  The map. It may or may not be initialized at this stage, but the module ensures to initialize itself once it is.
- Optionalconfig: CFG
  Optional configuration to initialize directly as soon as the map is ready.
Returns AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS, CFG>

Inherited from AbstractMapModule.constructor

Accessors

sourceAndLayerIDs

get sourceAndLayerIDs(): Record<keyof SOURCES_WITH_LAYERS, SourceWithLayerIDs>
Gets the source and layer identifiers for all sources managed by this module.

This property provides access to the MapLibre source and layer IDs that were created and are managed by this module. These IDs can be used to interact directly with MapLibre's API or to identify which layers belong to this module.

Returns Record<keyof SOURCES_WITH_LAYERS, SourceWithLayerIDs>
A record mapping each source name to its corresponding source ID and layer IDs. Each entry contains the MapLibre source identifier and an array of layer identifiers associated with that source.
Remarks
The returned IDs are useful when you need to:
- Directly manipulate layers using MapLibre's native API
- Identify which layers on the map belong to this module
- Set layer ordering or positioning relative to other layers
- Access source or layer properties through MapLibre methods
Example
```
const ids = myModule.sourceAndLayerIDs;
console.log(ids);
// {
//   mySource: {
//     sourceID: 'my-source-id',
//     layerIDs: ['layer-1', 'layer-2']
//   }
// }

// Use with MapLibre API
const map = myModule.mapLibreMap;
ids.mySource.layerIDs.forEach(layerId => {
  map.setLayoutProperty(layerId, 'visibility', 'visible');
});
```
Inherited from AbstractMapModule.sourceAndLayerIDs

Methods

applyConfig

applyConfig(config: CFG | undefined): void
Applies a configuration to this module.

This method updates the module's behavior and appearance based on the provided configuration. The configuration is stored internally and will be automatically reapplied if the map style changes.
Parameters
- config: CFG | undefined
  The configuration object to apply to the module. Pass undefined to reset the configuration to default values.
Returns void
Remarks
When a configuration is applied, the module updates its visual representation and behavior accordingly. The configuration persists across map style changes, ensuring consistent module behavior even when the map's base style is modified.

The given configuration replaces the current one rather than being merged into it. To change one part of it, use updateConfig.
Example
```
// Apply a new configuration
myModule.applyConfig({ visible: true, opacity: 0.8 });

// Reset to default configuration
myModule.applyConfig(undefined);
```
See
- resetConfig for a convenience method to reset configuration
- getConfig to retrieve the current configuration
Inherited from AbstractMapModule.applyConfig

cleanEventState

cleanEventState(options: CleanEventStateOptions): void
Takes the event state off one of the shown features.
Parameters
- options: CleanEventStateOptions
Returns void
Example
```
module.cleanEventState({ id: feature.id });
```

cleanEventStates

cleanEventStates(options?: CleanEventStatesOptions): void
Takes the given event states, or all of them, off the shown features.
Parameters
- Optionaloptions: CleanEventStatesOptions
Returns void
Example
```
module.cleanEventStates(); // every state
module.cleanEventStates({ states: ['hover'] }); // hovers only, selections stay
```

getConfig

getConfig(): NonNullable<CFG> | undefined
Retrieves a copy of the current module configuration.

This method returns a shallow copy of the configuration object that is currently applied to the module. If no configuration has been applied, it returns undefined.

Returns NonNullable<CFG> | undefined
A shallow copy of the current configuration object, or undefined if no configuration is currently applied. The returned object is a copy to prevent unintended modifications to the internal state.
Remarks
The returned configuration object is a shallow copy, which means that while the top-level properties are copied, any nested objects or arrays are still referenced from the original configuration. This is sufficient for most use cases but should be kept in mind when dealing with complex configurations.
Example
```
// Apply a configuration
myModule.applyConfig({ visible: true, opacity: 0.8 });

// Later, retrieve the current configuration
const currentConfig = myModule.getConfig();
console.log(currentConfig); // { visible: true, opacity: 0.8 }

// When no config is applied
myModule.resetConfig();
console.log(myModule.getConfig()); // undefined
```
See
- applyConfig to modify the configuration
- resetConfig to clear the configuration
Inherited from AbstractMapModule.getConfig

getEventStates

getEventStates(): EventStateIds
Returns the ids of the shown features that have an event state, by state.

Returns EventStateIds
Remarks
The read side of putEventState and cleanEventStates: it reflects those and the states user interactions put. The ids are those getShown() and the event handlers hand back, so each can go straight back into putEventState.
Example
```
// Keep a list in sync with the selected feature
const { click: [selectedID] = [] } = module.getEventStates();

// Is this feature hovered?
const hovered = module.getEventStates().hover?.includes(feature.id) ?? false;
```

isVisible

isVisible(): boolean

Whether the module is set to be shown: its visible setting, true unless set. A shown module with nothing shown draws nothing; getShown() returns what is shown.

Returns boolean

putEventState

putEventState(options: PutEventStateOptions): void
Puts an event state on one of the shown features, as a user interaction would.
Parameters
- options: PutEventStateOptions
Returns void
Remarks
The state is what the module's own layers draw (place pins and entry points, route outlines, geometries, details-module incidents, area-analytics cells), what layers of yours read with ['get', 'eventState'], and what getEventStates returns. It lasts as long as the shown feature does: through setVisible, style and configuration changes, not through a new show, a clear or a setStyle with resetState.
Example
```
// Select a feature from a list, as a click would
module.putEventState({ id: feature.id, state: 'click' });

// Hover a second one without taking the hover off the first
module.putEventState({ index: 2, state: 'hover', mode: 'add' });
```

resetConfig

resetConfig(): void
Resets the configuration of this module to its default values.

This is a convenience method that clears any previously applied configuration and restores the module to its initial state. This is equivalent to calling applyConfig(undefined).

Returns void
Remarks
After calling this method, the module will behave as if no configuration was ever applied. Any custom settings, styling, or behavior modifications will be removed and replaced with default values.
Example
```
// Apply some configuration
myModule.applyConfig({ visible: true, opacity: 0.5 });

// Later, reset to defaults
myModule.resetConfig();
```
See
- applyConfig to apply a new configuration
- getConfig to retrieve the current configuration before resetting
Inherited from AbstractMapModule.resetConfig

setVisible

setVisible(visible: boolean): void
Shows or hides everything the module draws.
Parameters
- visible: boolean
Returns void
Remarks
Stored as visible in the configuration. Showing and clearing data never change it: a hidden module keeps its data, through style changes too, and draws it again on setVisible(true).

Showing leaves hidden what the configuration turns off: a route section type that is off, the layers a place marker type does not use.
Example
```
module.setVisible(false);
await module.show(data); // stays hidden
module.setVisible(true);
```

updateConfig

updateConfig(partial: Partial<NonNullable<CFG>>): void
Changes part of the configuration and keeps the rest.

The given properties are laid over the current configuration — one level deep, so a nested object you pass replaces the nested object that was there — and the result is applied with applyConfig. This is the same on every module, whatever its applyConfig does with a whole configuration.
Parameters
- partial: Partial<NonNullable<CFG>>
  The properties to change.
Returns void
Example
```
routing.applyConfig({ displayUnits: 'imperial', color: '#0a3653' });
routing.updateConfig({ color: '#c2185b' }); // displayUnits stays imperial
```
See
applyConfig to apply a whole configuration
Inherited from AbstractMapModule.updateConfig

`Protected`waitUntilModuleReady

waitUntilModuleReady(): Promise<void>

Returns Promise<void>

Inherited from AbstractMapModule.waitUntilModuleReady

Class AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS, CFG>Abstract

Remarks

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Accessors

Methods

Constructors

Protectedconstructor

Type Parameters

Parameters

Returns AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS, CFG>

Accessors

sourceAndLayerIDs

Returns Record<keyof SOURCES_WITH_LAYERS, SourceWithLayerIDs>

Remarks

Example

Methods

applyConfig

Parameters

Returns void

Remarks

Example

See

cleanEventState

Parameters

Returns void

Example

cleanEventStates

Parameters

Returns void

Example

getConfig

Returns NonNullable<CFG> | undefined

Remarks

Example

See

getEventStates

Returns EventStateIds

Remarks

Example

isVisible

Returns boolean

putEventState

Parameters

Returns void

Remarks

Example

resetConfig

Returns void

Remarks

Example

See

setVisible

Parameters

Returns void

Remarks

Example

updateConfig

Parameters

Returns void

Example

See

ProtectedwaitUntilModuleReady

Returns Promise<void>

Settings

On This Page

Class AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS, CFG>`Abstract`

`Protected`constructor

`Protected`waitUntilModuleReady