Refactor ControlMap

src/components/ControlMap.js

@@ -19,93 +19,84 @@ export type ControlMapProps = {
   onChangeControl: (control: Control) => void
 };
 
-export default class ControlMap extends React.PureComponent<ControlMapProps> {
+const center = (props: ControlMapProps): Point =>
-  constructor(props: ControlMapProps) {
+  convertPoint([
-    super(props);
+    props.width / 2,
-  }
+    props.height / 2
+  ]);
 
-  get center(): Point {
+const iconColor = (control: Control, state: State): string => {
-    return convertPoint([
+  if (control.iconColor != null) {
-      this.props.width / 2,
+    return control.iconColor(state);
-      this.props.height / 2
-    ]);
   }
+  return "#000";
+};
 
-  render() {
+const createLeafletIcon = (control: Control, state: State) => {
-    return (
+  const icon = control.icon(state);
-      <Map center={this.center}
+  const iconClass = `${icon} mdi-36px`;
-        zoom={this.props.zoom}
+  return divIcon({
-        crs={CRS.Simple}
+    iconSize: point(36, 36),
-        leaflet={{}}>
+    iconAnchor: point(18, 18),
-        {this.renderMarkers()}
+    html: `<i class="${iconClass}"
-        {this.renderLayers()}
+        style="line-height: 1; color: ${iconColor(control, state)}"></i>`
-      </Map>
+  });
-    );
+};
-  }
 
-  renderMarkers() {
+const renderMarker = (props: ControlMapProps) =>
-    return map(this.props.controls, this.renderMarker.bind(this));
+  (control: Control, key: string) => (
-  }
+    <MqttContext.Consumer key={key}>
+      {({ state }) => (
+        <Marker position={convertPoint(control.position)}
+          icon={createLeafletIcon(control, state)}
+          onClick={() => props.onChangeControl(control)}
+        >
+        </Marker>
+      )}
+    </MqttContext.Consumer>
+  );
 
-  createLeafletIcon(control: Control, state: State) {
+const renderMarkers = (props: ControlMapProps) =>
-    const icon = control.icon(state);
+  map(props.controls, renderMarker(props));
-    const iconClass = `${icon} mdi-36px`;
-    return divIcon({
-      iconSize: point(36, 36),
-      iconAnchor: point(18, 18),
-      html: `<i class="${iconClass}"
-          style="line-height: 1; color: ${this.iconColor(control, state)}"></i>`
-    });
-  }
 
-  iconColor(control: Control, state: State): string {
+const renderLayer = (layer: Layer) => {
-    if (control.iconColor != null) {
+  const LayersControlType =
-      return control.iconColor(state);
+    layer.baseLayer ? LayersControl.BaseLayer : LayersControl.Overlay;
-    }
+  return (
-    return "#000";
+    <LayersControlType
-  }
+      key={layer.name}
+      name={layer.name}
+      checked={layer.defaultVisibility === "visible"}
+      removeLayer={(_layer) => {}} // eslint-disable-line fp/no-nil
+      removeLayerControl={(_layer) => {}} // eslint-disable-line fp/no-nil
+      // eslint-disable-next-line fp/no-nil
+      addOverlay={(_layer, _name, _checked) => {}}
+      // eslint-disable-next-line fp/no-nil
+      addBaseLayer={(_layer, _name, _checked) => {}}>
+      <ImageOverlay url={layer.image}
+        bounds={[
+          convertPoint(layer.bounds.topLeft),
+          convertPoint(layer.bounds.bottomRight)
+        ]}
+        opacity={layer.opacity || 1} />
+    </LayersControlType>
+  );
+};
 
-  renderMarker(control: Control, key: string) {
+const renderLayers = (props: ControlMapProps) => (
-    return (
+  <LayersControl position="topright">
-      <MqttContext.Consumer key={key}>
+    {props.layers.map(renderLayer)}
-        {({ state }) => (
+  </LayersControl>
-          <Marker position={convertPoint(control.position)}
+);
-            icon={this.createLeafletIcon(control, state)}
-            onClick={() => this.props.onChangeControl(control)}
-          >
-          </Marker>
-        )}
-      </MqttContext.Consumer>
-    );
-  }
 
-  renderLayers() {
+const ControlMap = (props: ControlMapProps) => (
-    return (
+  <Map center={center(props)}
-      <LayersControl position="topright">
+    zoom={props.zoom}
-        {this.props.layers.map(this.renderLayer)}
+    crs={CRS.Simple}
-      </LayersControl>
+    leaflet={{}}>
-    );
+    {renderMarkers(props)}
-  }
+    {renderLayers(props)}
+  </Map>
+);
 
-  renderLayer(layer: Layer) {
+export default ControlMap;
-    const LayersControlType =
-      layer.baseLayer ? LayersControl.BaseLayer : LayersControl.Overlay;
-    return (
-      <LayersControlType
-        key={layer.name}
-        name={layer.name}
-        checked={layer.defaultVisibility === "visible"}
-        removeLayer={(_layer) => {}}
-        removeLayerControl={(_layer) => {}}
-        addOverlay={(_layer, _name, _checked) => {}}
-        addBaseLayer={(_layer, _name, _checked) => {}}>
-        <ImageOverlay url={layer.image}
-          bounds={[
-            convertPoint(layer.bounds.topLeft),
-            convertPoint(layer.bounds.bottomRight)
-          ]}
-          opacity={layer.opacity || 1} />
-      </LayersControlType>
-    );
-  }
-}