Convert algorithms to JS

Author: fallaciousreasoning

src/components/MapPin.svelte

@@ -2,7 +2,7 @@
   import { toLonLat } from 'ol/proj'
   import { getOlContext } from '../ol/Map.svelte'
   import fragment from '../stores/fragment'
-  import { findPlace } from '../search/geocode'
+  import { findPlace } from '../search/nearest'
   import round from '../utils/round'
 
   const { map } = getOlContext()

src/search/geocode.ts

@@ -1,53 +1,45 @@
-// import initSearch, {search} from 'nz-search'
-
-const osmUrl = 'https://nominatim.openstreetmap.org/search'
-const nzPlacesUrl = "https://nz-places.now.sh/api/search";
-
-export interface GeocodeResult {
-    lat: number;
-    lon: number;
-    name: string;
-    type: string;
-}
-
-let initPromise: Promise<typeof import('nz-search')>;
-function getSearch() {
-    if (!initPromise) {
-        initPromise = (async () => {
-            const [places, searchApi] = await Promise.all([(await fetch('data/places.json')).arrayBuffer(), import('nz-search')])
-            await searchApi.default()
-            searchApi.load_data(new Uint8Array(places))
-            return searchApi
-        })()
+import { getPlaces, type Place } from './places';
+
+const getMatch = (queryParts: string[], place: Place) => {
+    const lowerName = place.name.toLowerCase();
+    let rank = 0
+    let lastMatchIndex: number | undefined = undefined
+
+    for (const part of queryParts) {
+        const matchIndex = lowerName.indexOf(part)
+        if (matchIndex === -1) return 0
+
+        // If this is the first part, rank it higher if its at the start than if its somewhere else.
+        if (lastMatchIndex === undefined) {
+            rank += (matchIndex === 0
+                ? 1
+                : 1 / matchIndex)
+        } else {
+            const numerator = matchIndex <= lastMatchIndex ? 0.5 : 1
+            rank += numerator / Math.abs(matchIndex - lastMatchIndex)
+        }
     }
-    return initPromise
+    return rank
 }
 
-const searchOsm = async (query: string): Promise<GeocodeResult[]> => {
-    // Hackily include the country because the nominatim API is terrible.
-    query = query + ", NZ";
-    const results: GeocodeResult[] = await fetch(`${osmUrl}?q=${encodeURIComponent(query)}&format=jsonv2`)
-        .then(r => r.json());
+const searchNzPlaces = async (query: string, maxResults = 100): Promise<Place[]> => {
+    const lowerQuery = query.toLowerCase()
+    const lowerQueryParts = lowerQuery.split(' ').filter(p => p)
 
-    for (const result of results) {
-        result['name'] = result['display_name'];
-    }
-    return results;
-}
+    const places = await getPlaces()
 
-const searchNzPlaces = async (query: string): Promise<GeocodeResult[]> => {
-    const api = await getSearch()
+    const results: Place[] = []
+    for (const place of places) {
+        const match = getMatch(lowerQueryParts, place)
+        if (match === 0) continue
 
-    const results = api.search(query, 100)
+        results.push(place)
+        if (results.length >= maxResults) break
+    }
     return results
 }
 
-export const findPlace = async (lat: number, lon: number) => {
-    const search = await getSearch()
-    return search.closest_place(lat, lon, 0.1)
-}
-
-export default async (query: string, sources=[searchNzPlaces]): Promise<GeocodeResult[]> => {
+export default async (query: string, sources = [searchNzPlaces]): Promise<Place[]> => {
     const results = await Promise.all(sources.map(s => s(query)));
     return results.reduce((prev, next) => [...prev, ...next], [])
 }

src/search/nearest.ts

@@ -0,0 +1,35 @@
+import { getPlaces, type Place } from "./places";
+
+const toRadians = (degrees: number) => degrees * Math.PI / 180
+
+export const getDistance = (lat1: number, lon1: number, lat2: number, lon2: number): number => {
+    const r = 6371.0; // radius of the earth in kilometers
+    const dLat = toRadians(lat2 - lat1);
+    const lLon = toRadians(lon2 - lon1);
+    const a = Math.sin(dLat / 2) ** 2
+        + Math.cos(toRadians(lat1))
+        * Math.cos(toRadians(lat2))
+        * Math.sin(lLon / 2) ** 2;
+    const c = 2 * Math.asin(Math.sqrt(a));
+    return r * c;
+}
+
+export const closestPlace = (lat: number, lon: number, places: Place[], maxDistance: number) => {
+    let minDistance = -1
+    let closest: Place | undefined
+
+    for (const place of places) {
+        const distance = getDistance(lat, lon, place.lat, place.lon)
+        if (distance < minDistance || !closest) {
+            minDistance = distance
+            closest = place
+        }
+    }
+
+    if (minDistance < maxDistance) {
+        return closest
+    }
+    return undefined
+}
+
+export const findPlace = async (lat: number, lon: number) => closestPlace(lat, lon, await getPlaces(), 0.1)

src/search/places.ts

@@ -0,0 +1,17 @@
+const url = '/data/places.json'
+
+export interface Place {
+    name: string,
+    lat: number,
+    lon: number,
+    type: string
+}
+
+let placesPromise: Promise<Place[]>;
+
+export const getPlaces = () => {
+    if (!placesPromise) {
+        placesPromise = fetch(url).then(r => r.json())
+    }
+    return placesPromise
+}