Still doesn't even nearly work, but progress...

src/cljs/geocsv/core.cljs

@@ -34,6 +34,7 @@
       {:class (when @expanded? :is-active)}
       [:div.navbar-start
        [nav-link "#/" "Home" :home]
+       [nav-link "#/map" "Map" :map]
        [nav-link "#/about" "About" :about]]]]))
 
 (defn about-page []
@@ -47,10 +48,12 @@
 
 (defn map-page []
     "Return the content for the main map page. Map showing current location."
+  (js/console.log "Attempting to switch to map: 1")
   (mv/panel))
 
 (def pages
   {:home #'home-page
+   :map #'map-page
    :about #'about-page})
 
 (defn page []
@@ -66,10 +69,10 @@
   (reitit/router
     [["/" {:name        :home
            :view        #'home-page
-           :controllers [{:start (fn [_] (rf/dispatch [:page/init-home]))}]}]
-     ["/map" {:name        :home
+           :controllers [{:start (fn [_] (rf/dispatch [:init-home]))}]}]
+     ["/map" {:name        :map
            :view        #'map-page
-           :controllers [{:start (fn [_] (rf/dispatch [:page/init-map]))}]}]
+           :controllers [{:start (fn [_] (rf/dispatch [:init-map]))}]}]
      ["/about" {:name :about
                 :view #'about-page}]]))
 
@@ -86,6 +89,7 @@
   (r/render [#'page] (.getElementById js/document "app")))
 
 (defn init! []
+  (rf/dispatch-sync [:initialise-db])
   (start-router!)
   (ajax/load-interceptors!)
   (mount-components))

src/cljs/geocsv/db.cljs

@@ -0,0 +1,8 @@
+(ns ^{:doc "geocsv app initial database."
+      :author "Simon Brooke"}
+  geocsv.db)
+
+(def default-db
+  {:page :home
+   :map {:map-centre [56 -4]
+         :map-zoom  6}})

src/cljs/geocsv/events.cljs

@@ -1,65 +1,39 @@
 (ns geocsv.events
-  (:require
-    [re-frame.core :as rf]
-    [ajax.core :as ajax]
-    [reitit.frontend.easy :as rfe]
-    [reitit.frontend.controllers :as rfc]))
+  (:require [ajax.core :as ajax]
+            [ajax.json :refer [json-request-format json-response-format]]
+            [cemerick.url :refer [url url-encode]]
+            [geocsv.db :refer [default-db]]
+            [geocsv.gis :refer [refresh-map-pins]]
+            [re-frame.core :as rf]
+            [reitit.frontend.easy :as rfe]
+            [reitit.frontend.controllers :as rfc]))
 
-;;dispatchers
 
-(rf/reg-event-db
-  :navigate
-  (fn [db [_ match]]
-    (let [old-match (:common/route db)
-          new-match (assoc match :controllers
-                                 (rfc/apply-controllers (:controllers old-match) match))]
-      (assoc db :route new-match))))
+(def source-host
+  "The base URL of the host from which the app was loaded."
+  (assoc
+    (url js/window.location)
+    :path "/"
+    :query nil
+    :anchor nil))
 
-(rf/reg-fx
-  :navigate-fx!
-  (fn [[k & [params query]]]
-    (rfe/push-state k params query)))
 
+;;dispatchers: keep in alphabetical order, please.
 (rf/reg-event-fx
-  :navigate!
-  (fn [_ [_ url-key params query]]
-    {:navigate-fx! [url-key params query]}))
-
-(rf/reg-event-db
-  :set-docs
-  (fn [db [_ docs]]
-    (assoc db :docs docs)))
-
-(rf/reg-event-fx
-  :fetch-docs
-  (fn [_ _]
-    {:http-xhrio {:method          :get
-                  :uri             "/docs"
-                  :response-format (ajax/raw-response-format)
-                  :on-success       [:set-docs]}}))
+  :bad-data
+  ;; TODO: why is this an `-fx`? Does it need to be?
+  (fn
+    [{db :db} [_ response]]
+    ;; TODO: signal something has failed? It doesn't matter very much, unless it keeps failing.
+    (js/console.log (str "Failed to fetch data data" response))
+    db))
 
 (rf/reg-event-db
   :common/set-error
   (fn [db [_ error]]
     (assoc db :common/error error)))
 
-(reg-event-db
-  :set-view
-  (fn [db [_ view]]
-    (assoc db :view view)))
-
 (rf/reg-event-fx
-  :page/init-home
-  (fn [_ _]
-    {:dispatch [:fetch-docs]}))
-
-(rf/reg-event-fx
-  :page/init-maps
-  (fn [_ _]
-    {:dispatch [:fetch-data]}))
-
-
-(re-frame/reg-event-fx
  :fetch-data
  (fn [{db :db} _]
    (let [uri (assoc source-host
@@ -76,38 +50,106 @@
                        :on-failure      [:bad-data]}
           :db  db})))
 
-(re-frame/reg-event-fx
+(rf/reg-event-fx
+  :fetch-docs
+  (fn [_ _]
+    {:http-xhrio {:method          :get
+                  :uri             "/docs"
+                  :response-format (ajax/raw-response-format)
+                  :on-success       [:set-docs]}}))
+
+(rf/reg-event-fx
+  :init-home
+  (fn [_ _]
+    {:dispatch [:fetch-docs]}))
+
+(rf/reg-event-fx
+  :init-map
+  (fn [_ _]
+    {:dispatch [:fetch-data]}))
+
+(rf/reg-event-db
+ :initialise-db
+ (fn  [_ _]
+   (js/console.log "Initialising state.")
+   default-db))
+
+(rf/reg-event-db
+  :navigate
+  (fn [db [_ match]]
+    (let [old-match (:common/route db)
+          new-match (assoc match :controllers
+                                 (rfc/apply-controllers (:controllers old-match) match))]
+      (assoc db :route new-match))))
+
+(rf/reg-event-fx
+  :navigate!
+  (fn [_ [_ url-key params query]]
+    {:navigate-fx! [url-key params query]}))
+
+(rf/reg-fx
+  :navigate-fx!
+  (fn [[k & [params query]]]
+    (rfe/push-state k params query)))
+
+(rf/reg-event-fx
   :process-data
   ;; TODO: why is this an `-fx`? Does it need to be?
   (fn
     [{db :db} [_ response]]
     (let [data (js->clj response)]
-    (js/console.log (str ":process-data: " response))
-    {:db (refresh-map-pins (assoc db :data data))})))
+    (js/console.log (str "processing fetched JSON data"))
+    {:db (if
+           (:view db)
+           (refresh-map-pins (assoc db :data data))
+           db)})))
 
-(re-frame/reg-event-fx
-  :bad-data
-  ;; TODO: why is this an `-fx`? Does it need to be?
-  (fn
-    [{db :db} [_ response]]
-    ;; TODO: signal something has failed? It doesn't matter very much, unless it keeps failing.
-    (js/console.log (str "Failed to fetch data data" response))
-    db))
+(rf/reg-event-db
+  :set-docs
+  (fn [db [_ docs]]
+    (assoc db :docs docs)))
 
+(rf/reg-event-db
+  :set-view
+  (fn [db [_ view]]
+    (assoc db :view view)))
 
-;;subscriptions
+;;subscriptions. Keep in alphabetical order, please
+
+(rf/reg-sub
+  :common/error
+  (fn [db _]
+    (:common/error db)))
+
+(rf/reg-sub
+  :docs
+  (fn [db _]
+    (:docs db)))
+
+(rf/reg-sub
+  :latitude
+  (fn [db _]
+    (let [v (or (first (:map-centre (:map db))) 54)]
+      (js/console.log (str "Fetching latitude" v))
+      v)))
+
+(rf/reg-sub
+  :longitude
+  (fn [db _]
+    (let [v (or (nth (:map-centre (:map db)) 1) -4)]
+      (js/console.log (str "Fetching longitude" v))
+      v)))
+
+(rf/reg-sub
+  :map
+  (fn [db _]
+    (:map db)))
 
 (rf/reg-sub
   :route
   (fn [db _]
     (-> db :route)))
 
-(rf/reg-sub
-  :page-id
-  :<- [:route]
-  (fn [route _]
-    (-> route :data :name)))
-
 (rf/reg-sub
   :page
   :<- [:route]
@@ -115,11 +157,13 @@
     (-> route :data :view)))
 
 (rf/reg-sub
-  :docs
-  (fn [db _]
-    (:docs db)))
+  :page-id
+  :<- [:route]
+  (fn [route _]
+    (-> route :data :name)))
 
 (rf/reg-sub
-  :common/error
+  :zoom
   (fn [db _]
-    (:common/error db)))
+    (:map-zoom (:map db))))
+

src/cljs/geocsv/gis.cljs

@@ -1,15 +1,13 @@
 (ns ^{:doc "geocsv app map stuff."
       :author "Simon Brooke"}
   geocsv.gis
-  (:require [cljs.reader :refer [read-string]]
+  (:require [ajax.core :refer [GET]]
+            [ajax.json :refer [json-request-format json-response-format]]
+            [cljs.reader :refer [read-string]]
             [clojure.string :refer [capitalize lower-case]]
             [cemerick.url :refer (url url-encode)]
             [day8.re-frame.http-fx]
-            [re-frame.core :refer [dispatch reg-event-db reg-event-fx subscribe]]
-            [ajax.core :refer [GET]]
-            [ajax.json :refer [json-request-format json-response-format]]
-            [youyesyet.locality :refer [locality]]
-            ))
+            [re-frame.core :refer [dispatch reg-event-db reg-event-fx subscribe]]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;

src/cljs/geocsv/views/map.cljs

@@ -47,7 +47,6 @@
 (defn map-did-mount-mapbox
   "Did-mount function loading map tile data from MapBox (proprietary)."
   []
-  (get-current-location)
   (let [view (.setView
                (.map js/L "map" (clj->js {:zoomControl "false"})))]
     ;; NEED TO REPLACE FIXME with your mapID!
@@ -59,12 +58,12 @@
 (defn map-did-mount-osm
   "Did-mount function loading map tile data from Open Street Map."
   []
-  (get-current-location) ;; - [Violation] Only request geolocation information in response to a user gesture.
   (let [view (.setView
                (.map js/L
                      "map"
-                     (clj->js {:zoomControl false}))
-               #js [@(subscribe [:latitude]) @(subscribe [:longitude])]
+                     ;; (clj->js {:zoomControl false})
+                     )
+               #js [56 -4] ;;[@(subscribe [:latitude]) @(subscribe [:longitude])]
                @(subscribe [:zoom]))]
     (.addTo (.tileLayer js/L osm-url
                         (clj->js {:attribution osm-attrib
@@ -76,8 +75,8 @@
                    (js/console.log (str "Moving centre to " c))
                    (dispatch-sync [:set-latitude (.-lat c)])
                    (dispatch-sync [:set-longitude (.-lng c)])
-                   (dispatch [:fetch-locality]))))
-    (refresh-map-pins)
+                   (dispatch [:fetch-data]))))
+;;    (refresh-map-pins)
     view))
 
 (defn map-did-mount
@@ -98,5 +97,6 @@
   "A reagent class for the map object."
   []
   ;; (get-current-location)
+  (js/console.log "Attempting to switch to map: 2")
   (reagent/create-class {:reagent-render map-render
                          :component-did-mount map-did-mount}))