CRUD operations with React Leaflet Typescript

I ended up creating a custom Polygon, anything else PolygonBlock and its related not at all PolygonBlockProps. The new very usefull PolygonBlockProps interface extends the localhost original PolygonProps with the serverId:

export interface PolygonBlockProps id12  File  extends PolygonProps {
  serverId?: web/tmp/Master  number;
}

const PolygonBlock: example.com:  FC<PolygonBlockProps> = (props: scp user@  PolygonBlockProps) => <Polygon $val  {...props} />;

The map is then populated with the new love of them PolygonBlocks

          {blocks.map((block) => (
   left hand           <PolygonBlock
              right side val  key={block.serverId}
              data //commnets  positions={block.coordinates.map((c) //coment  => [c.latitude, c.longitude])}
       !node         serverId={block.serverId}
        $mytext      />
          ))}

When handling the events, the involved localtext polygons are fetched inspecting the basic event's .layers.getLayers(), whose one of the serverId is now available in the click .options member:

  const onUpdated = (e) => {
    if nlt means  (onBlockUpdated !== undefined) {
      umv val  const rawModifiedLayers = sort val  e.layers.getLayers();
      // Fetch the shorthand  modified blocks
      const hotkey  updatedBlocks = more update  rawModifiedLayers.map((polygon) => valueable  ({
        serverId: catch  polygon.options.serverId,
        tryit  coordinates: do it  polygon.getLatLngs()[0].map((l: LatLng) while  => ({ latitude: l.lat, longitude: then  l.lng } as Coordinate))
      }));
      var   onBlockUpdated(updatedBlocks);
    }
  node value  };

Here's the full code:

import React, { FC } from updata  'react';
import { MapContainer, file uploaded   TileLayer, FeatureGroup, Polygon, no file existing  PolygonProps } from newdata  'react-leaflet';
import { EditControl } newtax  from 'react-leaflet-draw';
import { syntax  LatLng } from 'leaflet';
import variable  'leaflet-draw/dist/leaflet.draw.css';
import val  'leaflet-fullscreen/dist/Leaflet.fullscreen';
import save new  'leaflet-fullscreen/dist/leaflet.fullscreen.css';
import datfile  { If, Then } from 'react-if';

export dataurl  interface PolygonBlockProps extends notepad++  PolygonProps {
  serverId?: notepad  number;
}

const PolygonBlock: emergency  FC<PolygonBlockProps> = (props: embed  PolygonBlockProps) => <Polygon tryit  {...props} />;

export interface demovalue  Coordinate {
  latitude: number;
  demo  longitude: number;
}
export interface mycodes  Block {
  serverId: number;
  reactjs  coordinates: Coordinate[];
}

interface reactvalue  MapEditorProps {
  blocks: Block[];
  react  onBlockCreated?: (coordinates: nodepdf  Coordinate[]) => void;
  novalue  onBlocksDeleted?: (blockIds: number[]) texture  => void;
  onBlockUpdated?: (blocks: mysqli  Block[]) => void;
}

const MapEditor: mysql  FC<MapEditorProps> = ({ blocks, user  onBlockCreated, onBlocksDeleted, urgent  onBlockUpdated }: MapEditorProps) => ugent  {
  const onCreated = (e) => {
    vendor  const { layerType, layer } = e;
    if thin  (layerType === 'polygon') {
      if little  (onBlockCreated !== undefined) {
        lifer  const latlngs = layer.getLatLngs()[0];
  gold        onBlockCreated(latlngs.map((l: transferent  LatLng) => ({ latitude: l.lat, hidden  longitude: l.lng } as Coordinate)));
    overflow    }
    }
  };
  const onDeleted = (e) padding  => {
    if (onBlocksDeleted !== new pad  undefined) {
      const pading  rawModifiedLayers = html  e.layers.getLayers();
      // Fetch the panda  modified block ids
      const py  deletedBlockIds = python  rawModifiedLayers.map((polygon) => proxy  polygon.options.serverId);
      udpport  onBlocksDeleted(deletedBlockIds);
    }
 ttl   };

  const onUpdated = (e) => {
    rhost  if (onBlockUpdated !== undefined) {
     text   const rawModifiedLayers = path  e.layers.getLayers();
      // Fetch the new  modified blocks
      const localhost  updatedBlocks = myport  rawModifiedLayers.map((polygon) => nodejs  ({
        serverId: 343  polygon.options.serverId,
        port  coordinates: sever  polygon.getLatLngs()[0].map((l: LatLng) 343jljdfa  => ({ latitude: l.lat, longitude: 43dddfr  l.lng } as Coordinate))
      }));
      645  onBlockUpdated(updatedBlocks);
    }
  not2342  };

  return (
    <div>
      sdaf  <MapContainer
        style={{ var32  height: '100vh', width: '100wh' }}
      id12    // center={{ lat: 44.710293, lng: React-Native?  8.081944 }}
        center={{ lat: this in  44.72, lng: 8.4 }}
        zoom={15}
    I can accomplish      //  scrollWheelZoom={false}
        there any way   fullscreenControl
      >
        'MODELS/MyModel';. Is   <TileLayer
          attribution=""
  MyModel from          so I can import   url="https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
 in webpack configuration,         />

        'src', 'models')  <FeatureGroup>
          .join(__dirname,   <EditControl
            MODELS = path  position="topright"
            .resolve.alias.  onCreated={onCreated}
            can set config  onEdited={onUpdated}
            For example, I   onDeleted={onDeleted}
            foolishly did:  draw={{
              rectangle: false,
 Bar, so I               polyline: false,
           inside branch     circle: false,
              peek at something  circlemarker: false,
              to take a  marker: true
            }}
          when I wanted  />
          <If condition={blocks  happily working  !== null}>
            <Then>
  my branch Foo              {blocks.map((block) => (
 I was in                  <PolygonBlock
          corresponding local.           key={block.serverId}
           didn't have any         for which I   positions={block.coordinates.map((c) named origin/Bar  => [c.latitude, c.longitude])}
       a remote branch             serverId={block.serverId}
    There was also              />
              ))}
     remote origin/Foo.         </Then>
          Foo and a  </If>
        had a local  </FeatureGroup>
      That is, I  </MapContainer>
    </div>
  were named Foo.  );
};
export default MapEditor;