🎥 Make videos programmatically with React
import type {LayerSpecification} from '@maptiler/sdk';
import {useContext, useEffect, useRef, useMemo} from 'react';
import {
Freeze,
Sequence,
Internals,
useDelayRender,
type InteractiveBaseProps,
type InteractivePremountProps,
} from 'remotion';
import {MapTilerContext} from './MapTilerContext';
export type MapLayerProps = InteractiveBaseProps &
Pick<InteractivePremountProps, 'premountFor' | 'postmountFor'> & {
readonly beforeId?: string;
readonly layer: LayerSpecification;
};
const MapLayerContent = ({beforeId, layer: passedLayer}: MapLayerProps) => {
const {map, styleRevision} = useContext(MapTilerContext);
const sequence = useContext(Internals.SequenceContext);
const isPremountingOrPostmounting = Boolean(
sequence?.premounting || sequence?.postmounting,
);
const layer = useMemo(
(): LayerSpecification =>
isPremountingOrPostmounting
? {
...passedLayer,
layout: {...passedLayer.layout, visibility: 'none'},
}
: passedLayer,
[isPremountingOrPostmounting, passedLayer],
);
const previousLayerRef = useRef<LayerSpecification | null>(null);
const {continueRender, delayRender} = useDelayRender();
useEffect(() => {
if (!map || !map.style) {
return;
}
const loadingHandle = delayRender(`Drawing MapTiler layer ${layer.id}`);
let hasFinished = false;
const finish = () => {
if (hasFinished) {
return;
}
hasFinished = true;
continueRender(loadingHandle);
};
const previousLayer = previousLayerRef.current;
const existingLayer = map.getLayer(layer.id);
const layerWithDefinedProperties = Object.fromEntries(
Object.entries(layer).filter(([, value]) => value !== undefined),
) as LayerSpecification;
const sourceChanged =
previousLayer !== null &&
'source' in previousLayer &&
'source' in layer &&
(previousLayer.source !== layer.source ||
previousLayer['source-layer'] !== layer['source-layer']);
if (existingLayer && (existingLayer.type !== layer.type || sourceChanged)) {
map.removeLayer(layer.id);
}
if (!map.getLayer(layer.id)) {
map.addLayer(layerWithDefinedProperties, beforeId);
} else {
if ('paint' in layer || (previousLayer && 'paint' in previousLayer)) {
const previousPaint =
previousLayer && 'paint' in previousLayer
? previousLayer.paint
: undefined;
const paint = 'paint' in layer ? layer.paint : undefined;
for (const property of new Set([
...Object.keys(previousPaint ?? {}),
...Object.keys(paint ?? {}),
])) {
map.setPaintProperty(
layer.id,
property,
(paint as Record<string, unknown> | undefined)?.[property] ?? null,
);
}
}
if ('layout' in layer || (previousLayer && 'layout' in previousLayer)) {
const previousLayout =
previousLayer && 'layout' in previousLayer
? previousLayer.layout
: undefined;
const layout = 'layout' in layer ? layer.layout : undefined;
for (const property of new Set([
...Object.keys(previousLayout ?? {}),
...Object.keys(layout ?? {}),
])) {
map.setLayoutProperty(
layer.id,
property,
(layout as Record<string, unknown> | undefined)?.[property] ?? null,
);
}
}
if ('filter' in layer) {
map.setFilter(layer.id, layer.filter ?? null);
}
map.setLayerZoomRange(layer.id, layer.minzoom ?? 0, layer.maxzoom ?? 24);
if (beforeId && map.getLayer(beforeId)) {
map.moveLayer(layer.id, beforeId);
}
}
previousLayerRef.current = layer;
map.once('idle', finish);
map.triggerRepaint();
return () => {
map.off('idle', finish);
finish();
};
}, [beforeId, continueRender, delayRender, layer, map, styleRevision]);
useEffect(() => {
if (!map) {
return;
}
return () => {
if (!map.style) {
return;
}
if (map.getLayer(layer.id)) {
map.removeLayer(layer.id);
map.triggerRepaint();
}
};
}, [layer.id, map]);
return null;
};
export const MapLayer = ({
from,
durationInFrames,
trimBefore,
playbackRate,
loop,
freeze,
hidden,
name,
showInTimeline,
premountFor,
postmountFor,
...props
}: MapLayerProps) => {
const {
effectivePremountFor,
effectivePostmountFor,
freezeFrame,
isPremountingOrPostmounting,
premountingActive,
postmountingActive,
} = Internals.usePremounting({
from: from ?? 0,
durationInFrames: Internals.resolveSequenceDuration({
durationInFrames,
playbackRate,
loop,
}),
premountFor: premountFor ?? null,
postmountFor: postmountFor ?? null,
style: null,
styleWhilePremounted: null,
styleWhilePostmounted: null,
hideWhilePremounted: 'opacity',
});
return (
<Freeze frame={freezeFrame} active={isPremountingOrPostmounting}>
<Sequence
layout="none"
from={from}
durationInFrames={durationInFrames}
trimBefore={trimBefore}
playbackRate={playbackRate}
loop={loop}
freeze={freeze}
hidden={hidden}
showInTimeline={showInTimeline ?? false}
name={name ?? '<MapLayer>'}
_remotionInternalPremountDisplay={effectivePremountFor || null}
_remotionInternalPostmountDisplay={effectivePostmountFor || null}
_remotionInternalIsPremounting={premountingActive}
_remotionInternalIsPostmounting={postmountingActive}
>
<MapLayerContent {...props} />
</Sequence>
</Freeze>
);
};