react-native-mapsforge-vtm/lib/module/components/LayerMapsforge.js

React Native components to build vector maps using Mapsforges fork of vtm. Offline rendering of OpenStreetMap data. Android only

"use strict";

/**
 * External dependencies
 */
import { useEffect, useState } from 'react';

/**
 * Internal dependencies
 */
import useRefState from "../compose/useRefState.js";
import promiseQueue from "../promiseQueue.js";
import usePrevious from "../compose/usePrevious.js";
import useRenderStyleOptions from "../compose/useRenderStyleOptions.js";
import { MapLayerMapsforgeModule } from "../nativeMapModules.js";
import { BUILT_IN_THEMES } from "../constants.js";
const Module = MapLayerMapsforgeModule;
;
const LayerMapsforge = ({
  nativeNodeHandle,
  reactTreeIndex,
  mapFile,
  renderTheme = 'DEFAULT',
  renderStyle = '',
  renderOverlays = [],
  hasBuildings = true,
  hasLabels = true,
  enabledZoomMin = 1,
  enabledZoomMax = 30,
  onCreate,
  onRemove,
  onChange,
  onError
}) => {
  const renderStylePrev = usePrevious(renderStyle);

  // @ts-ignore
  const [random, setRandom] = useState(0);
  const [uuid, setUuid] = useRefState(null);
  const [triggerCreateNew, setTriggerCreateNew] = useState(null);
  const {
    renderStyleDefaultId
  } = useRenderStyleOptions({
    renderTheme,
    nativeNodeHandle: nativeNodeHandle,
    onError
  });
  const createLayer = () => {
    setUuid(false);
    promiseQueue.enqueue(() => {
      return Module.createLayer(nativeNodeHandle, mapFile, renderTheme, renderStyle, renderOverlays, !!hasBuildings, !!hasLabels, Math.round(enabledZoomMin), Math.round(enabledZoomMax), reactTreeIndex).then(response => {
        setUuid(response.uuid);
        setRandom(Math.random());
        null === triggerCreateNew ? onCreate ? onCreate(response) : null : onChange ? onChange(response) : null;
      }).catch(err => {
        console.log('ERROR', err);
        onError ? onError(err) : null;
      });
    });
  };
  useEffect(() => {
    if (uuid === null && nativeNodeHandle && mapFile) {
      createLayer();
    }
    return () => {
      if (uuid && nativeNodeHandle) {
        promiseQueue.enqueue(() => {
          return Module.removeLayer(nativeNodeHandle, uuid).then(removedUuid => {
            onRemove ? onRemove({
              uuid: removedUuid
            }) : null;
          }).catch(err => {
            console.log('ERROR', err);
            onError ? onError(err) : null;
          });
        });
      }
    };
  }, [nativeNodeHandle, !!uuid, triggerCreateNew]);

  // enabledZoomMin enabledZoomMax changed.
  useEffect(() => {
    if (nativeNodeHandle && uuid) {
      Module.updateEnabledZoomMinMax(nativeNodeHandle, uuid, Math.round(enabledZoomMin), Math.round(enabledZoomMax)).catch(err => {
        console.log('ERROR', err);
        onError ? onError(err) : null;
      });
    }
  }, [enabledZoomMin, enabledZoomMax]);
  useEffect(() => {
    if (nativeNodeHandle && uuid) {
      Module.toogleBuildings(nativeNodeHandle, uuid, hasBuildings).catch(err => {
        console.log('ERROR', err);
        onError ? onError(err) : null;
      });
    }
  }, [hasBuildings]);
  useEffect(() => {
    if (nativeNodeHandle && uuid) {
      Module.toggleLabels(nativeNodeHandle, uuid, hasLabels).catch(err => {
        console.log('ERROR', err);
        onError ? onError(err) : null;
      });
    }
  }, [hasLabels]);
  useEffect(() => {
    if (nativeNodeHandle) {
      if (uuid) {
        let shouldRecreate = true;
        if (renderStyle !== renderStylePrev && (!renderStylePrev || !renderStylePrev?.length) && renderStyle && renderStyleDefaultId && renderStyle === renderStyleDefaultId) {
          shouldRecreate = false;
        }
        if (shouldRecreate) {
          promiseQueue.enqueue(() => {
            return Module.removeLayer(nativeNodeHandle, uuid).then(() => {
              setUuid(null);
              setTriggerCreateNew(Math.random());
            }).catch(err => {
              console.log('ERROR', err);
              onError ? onError(err) : null;
            });
          });
        }
      } else if (uuid === null && mapFile) {
        setTriggerCreateNew(Math.random());
      }
    }
  }, [mapFile, renderTheme, renderStyle, renderOverlays && Array.isArray(renderOverlays) && renderOverlays.length ? renderOverlays.join('') : null]);
  return null;
};
LayerMapsforge.isMapLayer = true;
LayerMapsforge.BUILT_IN_THEMES = BUILT_IN_THEMES;
export default LayerMapsforge;
//# sourceMappingURL=LayerMapsforge.js.map