TomTom Maps for JavaScript
    Preparing search index...

    Class PlacesModule

    Base class for all Maps SDK map modules.

    This abstract class provides the foundation for creating map modules that can display and manage various types of data on a TomTom map. It handles module lifecycle management, including initialization, configuration updates, and automatic restoration after map style changes.

    All map modules extend this class to ensure consistent behavior across the SDK. The class manages the module's sources, layers, and configuration, automatically handling map style changes by restoring the module's state when needed.

    class CustomModule extends AbstractMapModule<MySourcesWithLayers, MyConfig> {
    constructor(tomtomMap: TomTomMap, config?: MyConfig) {
    super('geojson', tomtomMap, config);
    }
    // Implement abstract methods...
    }

    Hierarchy (View Summary)

    Index

    Accessors

    • 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.

      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
      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');
      });

    Methods

    • 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: PlacesModuleConfig | undefined

        The configuration object to apply to the module. Pass undefined to reset the configuration to default values.

      Returns void

      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.

      // Apply a new configuration
      myModule.applyConfig({ visible: true, opacity: 0.8 });

      // Reset to default configuration
      myModule.applyConfig(undefined);
      • resetConfig for a convenience method to reset configuration
      • getConfig to retrieve the current configuration
    • Applies additional feature properties to displayed places.

      Parameters

      • extraFeatureProps: { [key: string]: any }

        Object mapping property names to values or functions.

      Returns void

      Useful for adding computed properties or metadata for styling/filtering.

      placesModule.applyExtraFeatureProps({
      category: (place) => place.properties.poi?.localizedCategories?.[0],
      rating: (place) => place.properties.poi?.rating || 0,
      isOpen: true
      });
    • Updates the icon configuration for displayed places.

      Parameters

      Returns void

      • Changes apply immediately to currently shown places
      • Custom icons are loaded if not already in style
      • Other configuration properties remain unchanged
      placesModule.applyIconConfig({
      categoryIcons: [
      { category: 'RESTAURANT', id: 'restaurant-icon', image: '/icons/food.png' }
      ]
      });
    • Updates the text/label configuration for displayed places.

      Parameters

      Returns void

      Supports both functions and MapLibre expressions for dynamic text.

      // Use function
      placesModule.applyTextConfig({
      field: (place) => place.properties.poi?.name || 'Unknown'
      });

      // Use MapLibre expression
      placesModule.applyTextConfig({
      field: ['get', 'title'],
      size: 14,
      color: '#333'
      });
    • Updates the visual theme for displayed places.

      Parameters

      • theme: PlacesTheme

        The theme style to apply to place markers.

      Returns void

      Available Themes:

      • pin: Traditional teardrop-shaped map pins
      • circle-icon: Simple circular markers (previously named circle)
      • base-map: Mimics the map's built-in POI layer style with category icons (combines main, selected, and micro). For micro-only rendering, hide the main layer via layers.main.layout.visibility = 'none'.

      Changes apply immediately to all currently shown places. Other configuration properties (icon config, text config) remain unchanged.

      // Switch to pin markers
      placesModule.applyTheme('pin');

      // Use simple circles
      placesModule.applyTheme('circle-icon');

      // Match map's POI style (ideal to blend in)
      placesModule.applyTheme('base-map');
    • Removes an event state from a specific place.

      Parameters

      Returns void

      placesModule.cleanEventState({ index: 0 });
      
    • Removes event states from multiple places.

      Parameters

      Returns void

      // Remove all event states
      placesModule.cleanEventStates();

      // Remove only hover states
      placesModule.cleanEventStates({ states: ['hover'] });
    • Removes all places from the map.

      Returns Promise<void>

      • Clears all displayed places
      • Does not reset styling configuration
      • Module remains initialized and ready for new data
      await placesModule.clear();
      
    • Removes all connection lines from the map, leaving displayed places intact.

      Returns Promise<void>

      await placesModule.clearConnections();
      
    • 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<PlacesModuleConfig> | 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.

      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.

      // 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
    • Programmatically sets an event state on a specific place.

      Parameters

      Returns void

      Use this to make places appear clicked or hovered programmatically.

      // Make first place appear clicked
      placesModule.putEventState({
      index: 0,
      state: 'click',
      mode: 'put'
      });
    • 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

      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.

      // Apply some configuration
      myModule.applyConfig({ visible: true, opacity: 0.5 });

      // Later, reset to defaults
      myModule.resetConfig();
      • applyConfig to apply a new configuration
      • getConfig to retrieve the current configuration before resetting
    • Displays the given places on the map.

      Parameters

      • places: Place | Place[] | Places

        Place data to display. Can be a single Place, array of Places, or a Places FeatureCollection.

      Returns Promise<void>

      Behavior:

      • Replaces any previously shown places
      • Applies current module styling configuration
      • Automatically generates labels if text config is set
      • Waits for module to be ready before displaying

      Data Sources:

      • TomTom Search API results
      • Custom place objects matching the Place interface
      • GeoJSON Point features

      Display search results:

      import { search } from '@tomtom-international/maps-sdk-js/services';

      const results = await search({ query: 'coffee' });
      await placesModule.show(results);

      Display single place:

      await placesModule.show({
      type: 'Feature',
      geometry: { type: 'Point', coordinates: [4.9041, 52.3676] },
      properties: {
      address: { freeformAddress: 'Amsterdam' },
      poi: { name: 'Amsterdam Central' }
      }
      });

      Display multiple places:

      await placesModule.show([place1, place2, place3]);
      
    • Displays connection lines between pairs of places on the map.

      Parameters

      • connections: PlaceConnectionDisplay[]

        List of connections to render. Each connection has a from and to endpoint, expressed either as a Place or as the id of a place currently shown by this module.

      Returns Promise<void>

      Behavior:

      • Replaces any previously shown connections
      • Connections whose id reference cannot be resolved against the currently shown places are silently skipped
      • When PlaceConnectionsConfig.label is set on the module config, the returned string is rendered as a label along each line, slightly offset to the side. Without a label function, no label is shown.
      • Calling show() or clear() pre-clears connections, since their endpoints may no longer be on the map.
      const places = await PlacesModule.get(map, {
      connections: {
      label: (c) => `${c.distanceMeters} m`
      }
      });
      await places.show([station, ...cafes]);
      await places.showConnections(
      cafes.features.map((cafe) => ({
      from: station.id,
      to: cafe.id,
      distanceMeters: Math.round(cafe.properties.dist ?? 0),
      })),
      );