namazu-ts 0.1.0

package/src/sismomap.ts

@@ -0,0 +1,108 @@
+import maplibregl from 'maplibre-gl';
+import { EventGeoJSON, mapLayers, SisEvent } from './types';
+import { isEventGeoJSONProperties, isEventGeoJSON } from './utils';
+import { bbox } from '@turf/turf';
+import { EventToEventGeoJSON } from './maputils';
+
+export class SismoMap {
+    name: string;
+    map: maplibregl.Map;
+    descPopup: maplibregl.Popup;
+
+    /**
+     * Not meant to use, use createMap instead
+     */
+    constructor(
+        name: string,
+        map: maplibregl.Map,
+        descPopup: maplibregl.Popup
+    ) {
+        this.name = name;
+        this.map = map;
+        this.descPopup = descPopup;
+    }
+
+    /**
+     * Removes all user-made layers
+     */
+    clear() {
+        mapLayers.forEach((title) => {
+            if (this.map.getLayer(title)) {
+                this.map.removeLayer(title);
+            }
+            if (this.map.getSource('src')) {
+                this.map.removeSource('src');
+            }
+        });
+    }
+
+    /**
+     * @param eventOrList Can either be a single Event (via /events API) or a FDSN GeoJSON
+     * @param moveView True = The view moves on the events' bounding box while displaying (does not affect user's possible behaviour on the map)
+     * @param clear True = The map is cleared before displaying the events
+     */
+    displayEvents(
+        eventOrList: SisEvent | EventGeoJSON,
+        moveView: boolean = true,
+        clear: boolean = true
+    ) {
+        let eventList: EventGeoJSON;
+
+        // Type guard to disting the overloading cases
+        if (isEventGeoJSON(eventOrList)) {
+            eventList = eventOrList;
+        } else {
+            eventList = EventToEventGeoJSON(eventOrList as SisEvent);
+        }
+
+        if (clear) {
+            this.clear();
+        }
+        if (eventList.features.length == 0) return;
+
+        this.map.addSource('src', { type: 'geojson', data: eventList as any });
+        eventList.features.forEach((feature) => {
+            let eventType: string;
+            let typeName: string;
+            if (!isEventGeoJSONProperties(feature.properties)) {
+                eventType = feature.properties.eventType;
+                typeName = 'eventType';
+            } else {
+                eventType = feature.properties.type;
+                typeName = 'type';
+            }
+            let layerName = eventType == null ? 'event' : eventType;
+            if (this.map.getLayer(layerName)) return;
+            this.map.addLayer({
+                id: layerName,
+                source: 'src',
+                type: 'circle',
+                paint: {
+                    // Inspired by https://renass.unistra.fr/js/events.js
+                    'circle-radius': ['*', 8, ['ln', ['+', 1, ['get', 'mag']]]],
+                    'circle-color': '#B42222',
+                    'circle-opacity': 0.8,
+                    'circle-stroke-width': 1,
+                    'circle-stroke-opacity': 0.9,
+                },
+                filter: ['==', eventType, ['get', typeName]],
+            });
+        });
+        if (moveView) {
+            if (eventList.features.length == 1) {
+                let lng: number = eventList.features[0].geometry.coordinates[0];
+                let lat: number = eventList.features[0].geometry.coordinates[1];
+                this.map.flyTo({ center: [lng, lat], zoom: 6 });
+            } else {
+                // Inter-library operability is annoying, this line will always work with the types i'll give it
+                let bounds = bbox(eventList as any);
+                let margin = [-0.5, -0.5, 0.5, 0.5];
+                for (let i = 0; i < 4; i++) {
+                    bounds[i] += margin[i];
+                }
+
+                this.map.fitBounds(bounds as any);
+            }
+        }
+    }
+}

package/src/types.ts

@@ -0,0 +1,237 @@
+import maplibregl from 'maplibre-gl';
+import 'maplibre-gl/dist/maplibre-gl.css';
+
+export const mapLayers: Array<string> = [
+    'event',
+    'earthquake',
+    'quarry blast',
+    'thunder',
+    'mining-explosion',
+    'chemical explosion',
+    'building collapse',
+    'nuclear explosion',
+    'mine collapse',
+    'sonic boom',
+    'rockslide',
+    'ice quake',
+    'outside of network interest',
+    'landslide',
+    'explosion',
+    'induced',
+    'stations-layer',
+];
+
+export type EventGeojsonDescriptionProperty = {
+    fr: string;
+    en: string;
+};
+
+export type EventGeoJSONProperties = {
+    type: string;
+    time: Date;
+    description: EventGeojsonDescriptionProperty;
+    depth: number;
+    url: string[];
+    automatic: boolean;
+    latitude: number;
+    longitude: number;
+    mag: number;
+    magType: string;
+};
+
+export type EventFeature<T = EventGeoJSONProperties | SisEvent> = {
+    id: string;
+    type: string;
+    properties: T;
+    geometry: {
+        type: string;
+        coordinates: [number, number];
+    };
+};
+
+export type EventGeoJSON = {
+    type: string;
+    features: EventFeature[];
+};
+
+export type Origin = {
+    id: number;
+    eventID: number;
+    eventPreferred: boolean;
+    time: Date;
+    timeUncertainty: number;
+    timeConfidenceLevel: number;
+    latitude: number;
+    latitudeUncertainty: number;
+    latitudeConfidenceLevel: number;
+    longitude: number;
+    longitudeUncertainty: number;
+    longitudeConfidenceLevel: number;
+    depth: number;
+    depthUncertainty: number;
+    depthUsed: number;
+    depthType: number;
+    methodID: string;
+    earthmodelID: string;
+    automatic: boolean;
+    evaluationStatus: string;
+    originType: string;
+    agency: string;
+    author: string;
+    createdAt: Date;
+    insertedAt: Date;
+    updatedAt: Date;
+};
+
+export type Magnitude = {
+    id: number;
+    eventID: number;
+    originID: number;
+    eventPreferred: boolean;
+    magnitude: number;
+    magnitudeUncertainty: number;
+    magnitudeType: number;
+    methodID: string;
+    stationCount: number;
+    evaluationStatus: string;
+    agency: string;
+    author: string;
+    createdAt: Date;
+    insertedAt: Date;
+    updatedAt: Date;
+};
+
+export type Survey = {
+    name: string;
+    key: string;
+    eventPublicID: string;
+    opened: boolean;
+};
+
+// Had to change the name from Event to SisEvent because Event is already
+// taken by TS and it messed with the compiler and LSPs
+export type SisEvent = {
+    id: number;
+    zoneID: number;
+    publicid: string;
+    eventType: string;
+    localtime: Date;
+    timezone: string;
+    felt: boolean;
+    preferredOrigin: Origin;
+    preferredMagnitude: Magnitude;
+    insertedAt: Date;
+    updatedAt: Date;
+};
+
+export type FDSNQueryOptions = {
+    starttime?: Date;
+    endtime?: Date;
+    minlatitude?: number;
+    maxlatitude?: number;
+    minlongitude?: number;
+    maxlongitude?: number;
+    latitude?: number;
+    longitude?: number;
+    minradius?: number;
+    maxradius?: number;
+    mindepth?: number;
+    maxdepth?: number;
+    minmagnitude?: number;
+    maxmagnitude?: number;
+    magnitudetype?: string;
+    eventtype?: string;
+    includeallorigins?: boolean;
+    includeallmagnitudes?: boolean;
+    includearrivals?: boolean;
+    eventid?: string;
+    limit?: number;
+    offset?: number;
+    orderby?: string;
+    catalog?: string;
+    contributor?: string;
+    updatedafter?: string;
+    format?: string;
+    nodata?: string;
+};
+
+// This is called typescript branding and makes FDSN... not usable when CleanedFDSN... is expected
+export type CleanedFDSNQueryOptions = FDSNQueryOptions & { __brand: 'Cleaned' };
+
+export type City = {
+    latitude: number;
+    longitude: number;
+    name: string;
+    id: number;
+    population: number;
+    administrativeCode: string;
+};
+
+export type Street = {
+    latitude: number;
+    longitude: number;
+    name: string;
+};
+
+export type Testimony = {
+    key: string;
+    eventPublicID: string;
+    formID: number;
+    naiveFeltTime: Date;
+    feltTime: Date;
+    timezone: String;
+    highlighted: boolean;
+    utcOffset: number;
+    quality: number;
+    userEvaluationStatus: string;
+    source: string;
+    administrativeCodeType: string;
+    administrativeCode: string;
+    geocodingType: string;
+    longitude: number;
+    latitude: number;
+};
+
+export type QuestionGroup = {
+    id: number;
+    text: string;
+};
+
+export type QuestionCondition = number[];
+
+export type QuestionChoice = {
+    id: number;
+    value: string;
+    url?: string;
+    order: number;
+};
+
+export type Question = {
+    id: number;
+    groupID: number;
+    type: string;
+    text: string;
+    subtext: string;
+    answerType: string;
+    required: boolean;
+    order: number;
+    multiple: boolean;
+    conditions: QuestionCondition[];
+    choices: QuestionChoice[];
+};
+
+export type Answer = {
+    id: number;
+    question_id: number;
+    value: string;
+    choices: number[];
+};
+
+export type Form = {
+    default: boolean;
+    id: number;
+    name: string;
+    type: string;
+    groups: QuestionGroup[];
+    questions: Question[];
+};

package/src/utils.ts

@@ -0,0 +1,20 @@
+import { SisEvent, EventGeoJSON, EventGeoJSONProperties } from './types';
+// This file is for library-only functions, it should not be exported outside of the module
+
+export function formatString(str: string): string {
+    return str
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/\s+/g, '-')
+        .toLowerCase()
+        .normalize('NFC');
+}
+
+export function isEventGeoJSONProperties(
+    obj: SisEvent | EventGeoJSONProperties
+): obj is EventGeoJSONProperties {
+    return !((obj as SisEvent).eventType !== undefined);
+}
+export function isEventGeoJSON(obj: SisEvent | EventGeoJSON): obj is EventGeoJSON {
+    return (obj as EventGeoJSON).features !== undefined;
+}

package/typedoc.json

@@ -0,0 +1 @@
+{}