FilterExpression: [null | string, "in" | "ni", null | (null | string | number | boolean)[]] | [null | string, "lt" | "gt" | "le" | "ge" | "eq" | "ne" | "cn" | "nc" | "is" | "isnt", null | string | number | boolean]

Layers in a Felt map hold geospatial data, but also configure how the data is rendered both on the map and in the legend. The data can be vector data such as Points, Lines, or Polygons, or raster data such as satellite images.

Each Layer can be grouped under a LayerGroup, and has associated LegendItems that represent how the layer is rendered in the legend.

You can control the visibility of layers, layer groups, and legend items using the setLayerVisibility, setLayerGroupVisibility, and setLegendItemVisibility methods.

When a Layer is styled to as categorical data or "classed" numeric data, there will be a LegendItem for each category or class. Each LegendItem can be controlled for visibility independently of the Layer, so you can turn on and off each category or class individually.

Index

Interfaces

• Feature

• RasterValue

Controller

• LayersController

Filters

• LayerFilters

• FilterLogicGate

• FilterExpression

• FilterTernary

• Filters

Layer Groups

• LayerGroup

• GetLayerGroupsConstraint

• LayerGroupChangeCallbackParams

Layers

• Layer

• GetLayersConstraint

• LayerChangeCallbackParams

• GetRenderedFeaturesConstraint

• LayerProcessingStatus

Legend Items

• LegendItem

• LegendItemIdentifier

• LegendItemsConstraint

• LegendItemChangeCallbackParams

A feature is a single geographical item in a layer. The unique ID for a feature is a compound key made up of the layer ID and the feature ID.

Properties

id

id: string | number

The identifier of the feature, unique within the layer.

layerId

layerId: string

The identifier of the layer that the feature belongs to.

geometryType

geometryType: "Point" | "Polygon" | "MultiPolygon" | "LineString" | string & {}

The type of geometry of the feature.

properties

properties: Record<string, unknown>

The properties of the feature, as a bag of attributes.

FilterTernary: [FilterTernary | FilterExpression | null | boolean, FilterLogicGate, FilterTernary | FilterExpression | null | boolean]

FilterLogicGate: "and" | "or"

The constraints to apply when getting layers.

Properties

ids?

optional ids: string[]

The ids of the layers to get.

The constraints to apply when getting layer groups.

Properties

ids?

optional ids: string[]

The ids of the layer groups to get.

Filters can be used to change which features in a layer are rendered. Filters can be applied to a layer by the setLayerFilters method on the Felt controller.

Remarks

The possible operators are:

• lt: Less than

• gt: Greater than

• le: Less than or equal to

• ge: Greater than or equal to

• eq: Equal to

• ne: Not equal to

• cn: Contains

• nc: Does not contain

The allowed boolean operators are:

• and: Logical AND

• or: Logical OR

Example

Properties

id

id: string

A string identifying the layer group.

name

name: string

The name of the layer group. This is shown in the legend.

caption

caption: null | string

The caption of the layer group. This is shown in the legend.

layerIds

layerIds: string[]

The ids of the layers in the layer group.

Remarks

You can use these ids to get the full layer objects via the getLayers method.

visible

visible: boolean

Whether the layer group is visible or not.

shownInLegend

shownInLegend: boolean

Whether the layer group is shown in the legend or not.

bounds

bounds: null | [number, number, number, number]

The bounding box of the layer group.

FeltBoundary

Constraints for the getRenderedFeatures method. This can include layer constriants, spatial constraints, or both. If no constraints are provided, all rendered features will be returned.

Properties

areaQuery?

optional areaQuery: {coordinates: LatLng; } | {boundary: [number, number, number, number]; }

The area to query for rendered features. This can be specific coordinates or a FeltBoundary. If omitted, the entire viewport will be queried.

layerIds?

optional layerIds: string[]

The ids of the layers to get rendered features for.

Properties

id

id: string

The string identifying the layer

groupId

groupId: null | string

The ID of the layer group that the layer belongs to.

Layers that appear at the root level in Felt will not have a group ID.

name

name: string

The name of the layer can be displayed in the Legend, depending on how the layer's legend is configured in its style.

caption

caption: null | string

The layer's caption is shown in the legend.

description

description: null | string

The layer description forms part of the layer's metadata. This is visible to users via the layer info button in the legend.

visible

visible: boolean

Whether the layer is visible or not.

shownInLegend

shownInLegend: boolean

Whether the layer is shown in the legend or not.

style

style: object

The FSL style for the layer.

See the FSL documentation for details on how to read and write styles.

As the types of the styles are very complex, we return object here and advise that you program defensively while reading the styles.

status

status: "processing" | "completed" | "failed" | "incomplete"

The current processing status of the layer.

geometryType

geometryType: null | string

The geometry type of the layer.

Remarks

This will generally be one of:

• "Point"

• "Line"

• "Polygon"

• "Raster"

• null

When the layer is processing, or it is a data-only layer, it will be null. You should expect this to be able to be any string, however, as more geometry types can be added in the future.

bounds

bounds: null | [number, number, number, number]

The bounding box of the layer. If the layer is processing, or the bounds have otherwise not been calculated or are not available, this will be null.

FeltBoundary

The parameters for the onLayerGroupChange listener.

Properties

layerGroup

layerGroup: null | LayerGroup

The filters that are currently set on a layer.

A layer's filters are the combination of various different places in which filters can be applied.

Properties

style

style: Filters

Filters that are set in the layer's style. These are the lowest level of filters, and can only be set by editing the map.

components

components: Filters

Filters that are set in the layer's components, which are interactive elements in the legend. These can be set by viewers for their own session, but their default value can be set by the map creator.

ephemeral

ephemeral: Filters

Filters that are set ephemerally by viewers in their own session.

These are the filters that are set when the setLayerFilters method is called. There is no way to set these in the Felt UI - they can only be set using the SDK.

combined

combined: Filters

The combined result of all the filters set on the layer.

The parameters for the onLayerChange listener.

Properties

layer

layer: null | Layer

The new data for the layer or null if the layer was removed.

LayerProcessingStatus: "processing" | "completed" | "failed" | "incomplete"

This describes the processing status of a layer.

The various values are:

• processing: The layer has been uploaded or updated and is still processing.

• completed: The layer has been processed and can be viewed on the map.

• failed: The layer failed to process and cannot be viewed on the map.

• incomplete: The layer has not been processed.

A legend item, which often represents a sub-class of features in a layer in the case of categorical or classed layers.

Properties

title

title: string | string[]

The title of the legend item.

titleDependsOnZoom

titleDependsOnZoom: boolean

Whether the title depends on the zoom level or not. If it does, you need to call getLegendItem when the zoom level changes.

Note that as the zoom level changes, the onLegendItemChange handler will not be called, so you need to call getLegendItem yourself.

visible

visible: boolean

Whether the legend item is visible or not.

id

id: string

The id of the legend item.

layerId

layerId: string

The id of the layer the legend item belongs to.

The identifier for a legend item. It is a compound key of the layer to which the legend item belongs and the legend item's own id.

Properties

id

id: string

The id of the legend item.

layerId

layerId: string

The id of the layer the legend item belongs to.

Constraints for legend items. If nothing is passed, all legend items will be returned.

Properties

ids?

optional ids: {id: string;layerId: string; }[]

Array of legend item identifiers to constrain by.

layerIds?

optional layerIds: string[]

Array of layer ids to constrain legend items by.

The parameters for the onLegendItemChange listener.

Properties

legendItem

legendItem: null | LegendItem

The new data for the legend item or null if the legend item was removed.

A raster pixel value for a specific layer.

Properties

value

value: number

The value of the pixel.

layerId

layerId: string

The ID of the layer that the pixel belongs to.

categoryName

categoryName: null | string

The name of the category that the pixel belongs to.

color

color: null | {r: number;g: number;b: number;a: number; }

The color of the pixel. Each value is between 0 and 255.

The Layers controller allows you to get information about the layers on the map, and make changes to their visibility.

Layers can be organised into groups, and their groups can also have their visibility toggled.

Extended by

• FeltController

Methods

getLayer()

getLayer(id: string): Promise<null | Layer>

Get a single layer from the map by its id.

Parameters

Returns

Promise<null | Layer>

The requested layer.

Example

const layers = await felt.getLayer({ ids: ["layer-1", "layer-2"] });

getLayers()

getLayers(constraint?: GetLayersConstraint): Promise<(null | Layer)[]>

Gets layers from the map, according to the constraints supplied. If no constraints are supplied, all layers will be returned.

Parameters

Returns

Promise<(null | Layer)[]>

All layers on the map.

Remarks

The layers in the map, ordered by the order specified in Felt. This is not necessarily the order that they are drawn in, as Felt draws points above lines and lines above polygons, for instance.

Example

const layers = await felt.getLayers();

setLayerVisibility()

setLayerVisibility(visibility: SetVisibilityRequest): Promise<void>

Hide or show layers with the given ids.

Parameters

Returns

Promise<void>

Example

felt.setLayerVisibility({ show: ["layer-1", "layer-2"], hide: ["layer-3"] });

setLayerStyle()

setLayerStyle(params: {id: string;style: object; }): Promise<void>

Set the style for a layer using FSL, the Felt Style Language.

Changes are only for this session, and not persisted. This is useful to make temporary changes to a layer's style, such as to highlight a particular layer or feature.

See the FSL documentation for details on how to read and write styles.

If the style you set is invalid, you will receive an error explaining the problem in the rejected promise value.

Parameters

Returns

Promise<void>

Example

// first get the current style
const oldStyle = (await felt.getLayer("layer-1")).style;

felt.setLayerStyle({ id: "layer-1", style: {
  ...oldStyle,
  paint: {
    ...oldStyle.paint,
    color: "red",
  },
} });

getLayerGroup()

getLayerGroup(id: string): Promise<null | LayerGroup>

Get a layer group from the map by its id.

Parameters

Returns

Promise<null | LayerGroup>

The requested layer group.

Example

felt.getLayerGroup("layer-group-1");

getLayerGroups()

getLayerGroups(constraint?: GetLayerGroupsConstraint): Promise<(null | LayerGroup)[]>

Gets layer groups from the map, according to the constraints supplied. If no constraints are supplied, all layer groups will be returned in rendering order.

Parameters

Returns

Promise<(null | LayerGroup)[]>

The requested layer groups.

Example

const layerGroups = await felt.getLayerGroups({ ids: ["layer-group-1", "layer-group-2"] });

setLayerGroupVisibility()

setLayerGroupVisibility(visibility: SetVisibilityRequest): Promise<void>

Hide or show layer groups with the given ids.

Parameters

Returns

Promise<void>

Example

felt.setLayerGroupVisibility({ show: ["layer-group-1", "layer-group-2"], hide: ["layer-group-3"] });

getLegendItem()

getLegendItem(id: LegendItemIdentifier): Promise<null | LegendItem>

Allows you to get the state of a single legend item.

Parameters

Returns

Promise<null | LegendItem>

Example

const legendItem = await felt.getLegendItem({
  id: "legend-item-1",
  layerId: "layer-1",
})

getLegendItems()

getLegendItems(constraint?: LegendItemsConstraint): Promise<(null | LegendItem)[]>

Allows you to obtain the state of several legend items, by passing in constraints describing which legend items you want.

If you do not pass any constraints, you will receive all legend items.

Parameters

Returns

Promise<(null | LegendItem)[]>

Example

const legendItems = await felt.getLegendItems({layerId: "layer-1"});

setLegendItemVisibility()

setLegendItemVisibility(visibility: {show: LegendItemIdentifier[];hide: LegendItemIdentifier[]; }): Promise<void>

Hide or show legend items with the given identifiers.

Parameters

Returns

Promise<void>

Example

felt.setLegendItemVisibility({
  show: [{layerId: "layer-group-1", id: "item-1-0"}],
  hide: [{layerId: "layer-group-2", id: "item-2-0"}],
})

getLayerFilters()

getLayerFilters(layerId: string): Promise<null | LayerFilters>

Get the filters for a layer.

Parameters

Returns

Promise<null | LayerFilters>

Remarks

The return type gives you the filters split up into the various sources that make up the overall filters for a layer.

Example

const filters = await felt.getLayerFilters("layer-1");
console.log(filters.combined, filters.style, filters.ephemeral, filters.components);

setLayerFilters()

setLayerFilters(params: {layerId: string;filters: Filters;note: string; }): Promise<void>

Sets the ephemeral filters for a layer.

Parameters

Returns

Promise<void>

Example

felt.setLayerFilters({
  layerId: "layer-1",
  filters: ["AREA", "gt", 30_000],
});

getRenderedFeatures()

getRenderedFeatures(params?: GetRenderedFeaturesConstraint): Promise<Feature[]>

Get the features that are currently rendered on the map in the viewport.

Note that this is explicitly about the features that are rendered, which isn't necessarily a complete list of all the features in the viewport. This is because of the way features are tiled: at low zoom levels or high feature densities, many features are omitted from what is rendered on the screen.

Parameters

Returns

Promise<Feature[]>

Example

const features = await felt.getRenderedFeatures();

Events

onLayerChange()

onLayerChange(args: {options: {id: string; };handler: (change: LayerChangeCallbackParams) => void; }): VoidFunction

Adds a listener for when a layer changes.

Parameters

Returns

VoidFunction

A function to unsubscribe from the listener

Example

const unsubscribe = felt.onLayerChange({
  options: { id: "layer-1" },
  handler: ({layer}) => console.log(layer.bounds),
});

// later on...
unsubscribe();

onLayerGroupChange()

onLayerGroupChange(args: {options: {id: string; };handler: (change: LayerGroupChangeCallbackParams) => void; }): VoidFunction

Adds a listener for when a layer group changes.

Parameters

Returns

VoidFunction

A function to unsubscribe from the listener

Example

const unsubscribe = felt.onLayerGroupChange({
  options: { id: "layer-group-1" },
  handler: ({layerGroup}) => console.log(layerGroup.id),
});

// later on...
unsubscribe();

onLegendItemChange()

onLegendItemChange(args: {options: LegendItemIdentifier;handler: (change: LegendItemChangeCallbackParams) => void; }): VoidFunction

Adds a listener for when a legend item changes.

Parameters

Returns

VoidFunction

A function to unsubscribe from the listener

Example

const unsubscribe = felt.onLegendItemChange({
  options: { layerId: "layer-1", id: "item-1-0" },
  handler: ({legendItem}) => console.log(legendItem.visible),
});

// later on...
unsubscribe();