namazu-ts 0.1.0

package/src/client.ts

@@ -0,0 +1,552 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+import { CleanedFDSNQueryOptions, FDSNQueryOptions } from './types';
+import { ok, err, Result } from 'neverthrow';
+import {
+    Form,
+    Question,
+    Survey,
+    City,
+    Testimony,
+    QuestionChoice,
+    Answer,
+    EventGeoJSON,
+    SisEvent as NamazuEvent,
+} from './types';
+
+export class Client {
+    // Using a dedicated Axios Instance makes having multiple clients at once possible
+    private axiosInstance: AxiosInstance;
+
+    constructor(baseUrl: string) {
+        let cfg = { baseURL: baseUrl };
+        this.axiosInstance = axios.create(cfg);
+    }
+
+    setBaseUrl(baseUrl: string) {
+        this.axiosInstance.defaults.baseURL = baseUrl;
+    }
+
+    // Can either pass the AxiosRequest for more configurations or a route with a method
+    async apiCall<Type>(apiRoute: AxiosRequestConfig): Promise<Type>;
+    async apiCall<Type>(apiRoute: string, method?: string): Promise<Type>;
+    async apiCall<Type>(
+        apiRoute: string | AxiosRequestConfig,
+        method: string = 'GET'
+    ): Promise<Type> {
+        let request: AxiosRequestConfig;
+        if (typeof apiRoute == 'string') {
+            request = { method: method, url: apiRoute };
+        } else {
+            request = apiRoute;
+        }
+        let a: Promise<Type> = this.axiosInstance(request).then((response) => {
+            return response.data as Type;
+        });
+        return a;
+    }
+
+    async fetchForm(id: number): Promise<Form> {
+        return this.apiCall<Form>(`/api/v1/surveys/forms/${id}`);
+    }
+
+    getQuestion(form: Form, question_id: number): Question | undefined {
+        return form.questions.find((question) => question.id == question_id);
+    }
+
+    getChoice(
+        question: Question,
+        choice_id: number
+    ): QuestionChoice | undefined {
+        return question.choices.find((choice) => choice.id == choice_id);
+    }
+
+    async createIndividualTestimony(
+        eventPublicID: string,
+        email: string
+        // naiveFeltTime: Date | null
+    ): Promise<Testimony> {
+        return this.apiCall<Testimony>({
+            url: `/api/v1/testimonies`,
+            method: 'POST',
+            params: {
+                event_publicid: eventPublicID,
+                type: 'individual',
+                email: email,
+            },
+        });
+    }
+
+    async createCityTestimony(
+        eventPublicID: string,
+        cityID: number,
+        administrativeCodeType: string,
+        administrativeCode: string,
+        author: string,
+        email: string,
+        organization: string
+    ): Promise<Testimony> {
+        return this.apiCall<Testimony>({
+            method: 'post',
+            url: `/api/v1/testimonies`,
+            params: {
+                event_publicid: eventPublicID,
+                city_id: cityID,
+                administrative_code_type: administrativeCodeType,
+                administrative_code: administrativeCode,
+                type: 'city',
+                author: author,
+                email: email,
+                organization: organization,
+            },
+        });
+    }
+
+    async updateAnswer(
+        key: string,
+        questionID: number,
+        choices: number[],
+        value: string
+    ): Promise<Answer[]> {
+        return this.apiCall<Answer[]>({
+            method: 'put',
+            url: `/api/v1/testimonies/${key}/answers`,
+            params: {
+                question_id: questionID,
+                choices: choices,
+                value: value,
+            },
+        });
+    }
+
+    async updateTestimonyLocation(
+        key: string,
+        longitude: number,
+        latitude: number
+    ): Promise<Testimony | void> {
+        return this.apiCall<Testimony>({
+            method: 'put',
+            url: `/api/v1/testimonies/${key}`,
+            params: {
+                longitude: longitude,
+                latitude: latitude,
+            },
+        });
+    }
+
+    async setTestimonyDone(
+        key: string,
+        testimonyDone: boolean
+    ): Promise<Testimony | void> {
+        let evaluationStatus = testimonyDone ? 'final' : 'inprogress';
+
+        return this.apiCall<Testimony>({
+            method: 'put',
+            url: `/api/v1/testimonies/${key}`,
+            params: {
+                user_evaluation_status: evaluationStatus,
+            },
+        });
+    }
+
+    async fetchEvent(eventPublicID: string): Promise<NamazuEvent> {
+        return this.apiCall<NamazuEvent>(`/api/v1/events/${eventPublicID}`);
+    }
+
+    async fetchEvents(startDate: Date, endDate: Date): Promise<EventGeoJSON> {
+        return this.apiCall<EventGeoJSON>({
+            method: 'get',
+            url: '/api/v1/events/',
+            params: {
+                start_time: startDate.toISOString(),
+                end_time: endDate.toISOString(),
+            },
+        });
+    }
+
+    async fetchSurvey(surveyKey: string): Promise<Survey> {
+        return this.apiCall<Survey>({
+            method: 'get',
+            url: `/api/v1/surveys/cities/${surveyKey}`,
+        });
+    }
+
+    async fetchTestimony(key: string): Promise<Testimony> {
+        return this.apiCall<Testimony>(`/api/v1/testimonies/${key}`);
+    }
+
+    async fetchAnswers(key: string): Promise<Answer[]> {
+        return this.apiCall<Answer[]>(`/api/v1/testimonies/${key}/answers`);
+    }
+
+    async fetchCitiesByMatch(match: string): Promise<City[]> {
+        // Axios throws an error on not 2XX code so try/catch works
+        try {
+            return this.apiCall<City[]>({
+                method: 'get',
+                url: '/api/v1/cities',
+                params: {
+                    match: match,
+                },
+            });
+        } catch (error) {
+            return [];
+        }
+    }
+
+    async fetchCitiesByAdministrativeCode(
+        administrative_code_type: string,
+        administrative_code: string
+    ) {
+        return this.apiCall<City[]>({
+            method: 'get',
+            url: '/api/v1/cities',
+            params: {
+                administrative_code_type: administrative_code_type,
+                administrative_code: administrative_code,
+            },
+        });
+    }
+
+    // The next functions could be out of the object but i put them in so everything about forms
+    // is centralized and you just have to import the object once and that's all
+
+    formatMagnitude(magnitude: number): string {
+        return magnitude.toFixed(1);
+    }
+
+    getCurrentChoices(question_id: number, answers: Answer[]) {
+        const choices = answers.find(
+            (answer) => answer.question_id == question_id
+        )?.choices;
+
+        return choices ? choices : [];
+    }
+
+    getCurrentValue(question_id: number, answers: Answer[]) {
+        const answer = answers.find(
+            (answer) => answer.question_id == question_id
+        );
+
+        return answer?.value;
+    }
+
+    isConditionsSatisfied(
+        question: Question,
+        answers: Answer[] | undefined
+    ): boolean {
+        if (question.conditions.length === 0) {
+            return true;
+        }
+
+        if (!answers) {
+            return false;
+        }
+
+        const currentChoices = answers.map((answer) => answer.choices).flat();
+
+        return question.conditions
+            .map((condition) =>
+                condition.every((choice) => currentChoices.includes(choice))
+            )
+            .some((conditionsSatisfied) => conditionsSatisfied);
+    }
+
+    getLastAnsweredQuestion(
+        form: Form,
+        answers: Answer[]
+    ): Question | undefined {
+        const answeredQuestions = answers.map((answer) => answer.question_id);
+
+        return form.questions
+            .filter((question) => answeredQuestions.includes(question.id))
+            .sort((a, b) => (a.order > b.order ? -1 : 1))
+            .at(0);
+    }
+
+    getPreviousQuestion(
+        form: Form,
+        answers: Answer[],
+        currentQuestion?: Question
+    ): Question | undefined {
+        if (currentQuestion) {
+            return form.questions
+                .filter((question) => question.order < currentQuestion.order)
+                .sort((a, b) => (a.order > b.order ? -1 : 1))
+                .find((question) =>
+                    this.isConditionsSatisfied(question, answers)
+                );
+        }
+    }
+
+    getNextQuestion(
+        form: Form,
+        answers: Answer[],
+        currentQuestion?: Question
+    ): Question | undefined {
+        let minOrder = 0;
+
+        if (currentQuestion) {
+            minOrder = currentQuestion.order;
+        } else {
+            const lastAnsweredQuestion = this.getLastAnsweredQuestion(
+                form,
+                answers
+            );
+
+            if (lastAnsweredQuestion) {
+                minOrder = lastAnsweredQuestion.order;
+            }
+        }
+
+        return form.questions
+            .filter((question) => question.order > minOrder)
+            .sort((a, b) => (a.order < b.order ? -1 : 1))
+            .find((question) => this.isConditionsSatisfied(question, answers));
+    }
+
+    formatDateFR(dateString: Date): string {
+        const date = new Date(dateString);
+        return `${date.getDay().toString().padStart(2, '0')}/${date
+            .getMonth()
+            .toString()
+            .padStart(
+                2,
+                '0'
+            )}/${date.getFullYear().toString().padStart(2, '0')}`;
+    }
+
+    translateEventType(eventType: string): string {
+        return eventTypes.get(eventType) || 'Évènement';
+    }
+
+    buildQuery(
+        url: string,
+        options: CleanedFDSNQueryOptions
+    ): AxiosRequestConfig {
+        return {
+            method: 'get',
+            url: url,
+            params: options,
+        };
+    }
+
+    /**
+     * <!> IF YOU WANT TO CAST AS NAMAZU TYPE LATER, SET format:'json'
+     */
+    cleanQuery(
+        options: FDSNQueryOptions
+    ): Result<CleanedFDSNQueryOptions, Error> {
+        let query: FDSNQueryOptions = {};
+
+        if (options.eventid !== undefined) {
+            query.eventid = options.eventid;
+            return ok(query as CleanedFDSNQueryOptions);
+        }
+
+        if (options.starttime !== undefined) {
+            query.starttime = options.starttime;
+        } else {
+            // Default value is a month ago
+            let date = new Date();
+            date.setDate(date.getDate() - 30);
+            query.starttime = date;
+        }
+
+        if (options.endtime !== undefined) {
+            query.endtime = options.endtime;
+        }
+
+        if (options.minlatitude !== undefined) {
+            if (options.minlatitude <= 90 && options.minlatitude >= -90) {
+                query.minlatitude = options.minlatitude;
+            } else {
+                return err(
+                    Error('Minimum latitude should be between -90 and 90')
+                );
+            }
+        }
+
+        if (options.maxlatitude !== undefined) {
+            if (options.maxlatitude <= 90 && options.maxlatitude >= -90) {
+                query.maxlatitude = options.maxlatitude;
+            } else {
+                return err(
+                    Error('Maximum latitude should be between -90 and 90')
+                );
+            }
+        }
+
+        if (options.minlongitude !== undefined) {
+            if (options.minlongitude <= 180 && options.minlongitude >= -180) {
+                query.minlongitude = options.minlongitude;
+            } else {
+                return err(
+                    Error('Minimum longitude should be between -180 and 180')
+                );
+            }
+        }
+
+        if (options.maxlongitude !== undefined) {
+            if (options.maxlongitude <= 180 && options.maxlongitude >= -180) {
+                query.maxlongitude = options.maxlongitude;
+            } else {
+                return err(
+                    Error('Maximum longitude should be between -180 and 180')
+                );
+            }
+        }
+
+        // A bit ugly but one of these parameters can't live without the others
+        // so if one exists, i must create the others (if needed)
+        if (options.latitude !== undefined) {
+            if (options.latitude <= 90 && options.latitude >= -90) {
+                query.latitude = options.latitude;
+            } else {
+                return err(Error('Latitude should be between -90 and 90'));
+            }
+        }
+
+        if (options.longitude !== undefined) {
+            if (options.longitude <= 180 && options.longitude >= -180) {
+                query.longitude = options.longitude;
+            } else {
+                return err(Error('Longitude should be between -180 and 180'));
+            }
+        }
+        if (options.minradius !== undefined) {
+            if (options.minradius >= 0 && options.minradius <= 180) {
+                query.minradius = options.minradius;
+            } else {
+                return err(Error('Min radius should be between 0 and 180'));
+            }
+        }
+        if (options.maxradius !== undefined) {
+            if (options.maxradius >= 0 && options.maxradius <= 180) {
+                query.maxradius = options.maxradius;
+            } else {
+                return err(Error('Max radius should be between 0 and 180'));
+            }
+        }
+
+        const keys: (keyof FDSNQueryOptions)[] = [
+            'mindepth',
+            'maxdepth',
+            'minmagnitude',
+            'maxmagnitude',
+            'magnitudetype',
+            'eventtype',
+            'includeallorigins',
+            'includeallmagnitudes',
+            'includearrivals',
+            'catalog',
+            'contributor',
+            'updatedafter',
+        ];
+        keys.forEach((key) => {
+            if (options[key] !== undefined) {
+                // @ts-expect-error This line is safe as it's guarded above yet typescript errors because
+                // it doesn't understand the typeguard
+                query[key] = options[key];
+            }
+        });
+
+        if (options.limit !== undefined) {
+            if (options.limit > 0) {
+                query.limit = options.limit;
+            } else {
+                return err(Error("Limit can't be 0"));
+            }
+        }
+
+        if (options.offset !== undefined) {
+            if (options.offset > 0) {
+                query.offset = options.offset;
+            } else {
+                return err(Error("Offset can't be 0"));
+            }
+        }
+
+        let values = ['time', 'time-asc', 'magnitude', 'magnitude-asc'];
+        if (options.orderby !== undefined) {
+            if (values.includes(options.orderby)) {
+                query.orderby = options.orderby;
+            } else {
+                return err(
+                    Error(
+                        'Orderby must be time, time-asc, magnitude or magnitude-asc'
+                    )
+                );
+            }
+        }
+
+        values = ['xml', 'text', 'json'];
+        if (options.format !== undefined) {
+            if (values.includes(options.format)) {
+                query.format = options.format;
+            } else {
+                return err(Error('Format must be xml, text or json'));
+            }
+        }
+
+        values = ['204', '404'];
+        if (options.nodata !== undefined) {
+            if (values.includes(options.nodata)) {
+                query.nodata = options.nodata;
+            } else {
+                return err(Error('Nodata must be either 204 or 404'));
+            }
+        }
+
+        return ok(query as CleanedFDSNQueryOptions);
+    }
+}
+
+// Export in case people want official translations
+export const eventTypes = new Map<string, string>([
+    ['accidental explosion', 'explosion accidentelle'],
+    ['acoustic noise', 'bruit acoustique'],
+    ['anthropogenic event', 'évènement anthropique'],
+    ['avalanche', 'avalanche'],
+    ['blasting levee', 'digue de dynamitage'],
+    ['boat crash', 'accident de bateau'],
+    ['building collapse', 'effondrement de bâtiment'],
+    ['cavity collapse', 'effondrement de la cavité'],
+    ['chemical explosion', 'explosion chimique'],
+    ['collapse', 'effondrement'],
+    ['controlled explosion', 'explosion contrôlée'],
+    ['crash', 'accident'],
+    ['debris avalanche', 'avalanche de débris'],
+    ['earthquake', 'tremblement de terre'],
+    ['event', 'évènement'],
+    ['experimental explosion', 'explosion expérimentale'],
+    ['explosion', 'explosion'],
+    ['fluid extraction', 'extraction de fluide'],
+    ['fluid injection', 'injection de fluide'],
+    ['hydroacoustic event', 'évènement hydroacoustique'],
+    ['ice quake', 'tremblement de glace'],
+    ['induced', 'induit'],
+    ['industrial explosion', 'explosion industrielle'],
+    ['landslide', 'glissement de terrain'],
+    ['meteorite', 'météorite'],
+    ['mine collapse', 'effondrement de mine'],
+    ['mining explosion', 'explosion de mine'],
+    ['not existing', 'inexistant'],
+    ['not locatable', 'non localisable'],
+    ['not reported', 'non reporté'],
+    ['nuclear explosion', 'explosion nucléaire'],
+    ['other event', 'autre événement'],
+    ['outside of network interest', "en dehors de la zone d'intérêt"],
+    ['plane crash', "crash d'avion"],
+    ['quarry blast', 'tir de carrière'],
+    ['reservoir loading', 'chargement de réservoir'],
+    ['road cut', 'coupe de route'],
+    ['rock burst', 'éclat de roche'],
+    ['rockslide', 'éboulement'],
+    ['slide', 'glissement'],
+    ['snow avalanche', 'avalanche de neige'],
+    ['sonic blast', 'effet de souffle'],
+    ['sonic boom', 'détonation supersonique'],
+    ['thunder', 'tonnerre'],
+    ['train crash', 'crash de train'],
+    ['volcanic eruption', 'éruption volcanique'],
+]);

package/src/index.ts

@@ -0,0 +1,5 @@
+export { LngLatBounds } from 'maplibre-gl';
+export * from './maputils';
+export * from './client';
+export * from './sismomap';
+export * from './types';

package/src/maputils.ts

@@ -0,0 +1,116 @@
+import maplibregl from 'maplibre-gl';
+import 'maplibre-gl/dist/maplibre-gl.css';
+import geojson from 'geojson';
+import { SismoMap } from './sismomap';
+import {
+    SisEvent,
+    EventFeature,
+    EventGeoJSON,
+    EventGeojsonDescriptionProperty,
+    mapLayers,
+} from './types';
+import { isEventGeoJSONProperties } from './utils';
+
+/**
+ * Map creating function,
+ * @param name Name of the map, doesn't influence the behaviour
+ * @param containerID ID of the container that the map will be in
+ * @param bounds Optional bounds of the view when creating the map if absent, defaults to 0,0
+ * @return Promise<SismoMap> Promise that will be resolved when the map is created (bound zoom might not be over, but it's not a problem, zooms adjusts in real time to other functions)
+ */
+export async function createMap(
+    name: string,
+    containerID: string,
+    lang: string,
+    bounds?: maplibregl.LngLatBounds
+): Promise<SismoMap> {
+    const style: any = await fetch(
+        'https://static.franceseisme.fr/pmtiles-style.json'
+    ).then((r) => r.json());
+
+    style.projection = { type: 'globe' };
+
+    const map = new maplibregl.Map({
+        container: containerID,
+        style: style,
+        center: [0, 0],
+        zoom: 1, // Low value at the start so we get a "zoom in" animation when loading
+        attributionControl: false,
+    });
+
+    let descPopup = new maplibregl.Popup({
+        closeButton: false,
+        closeOnClick: false,
+        maxWidth: '200px',
+    });
+    let smap = new SismoMap(name, map, descPopup);
+
+    // We use a promise so that people won't use the map before it's fully
+    return new Promise<SismoMap>((resolve) => {
+        map.once('load', () => {
+            // We use that to have a flat map when zooming
+            // 5 is the value chosen because it covers all the zones of renass.unistra.franceseisme
+            // feel free to change to your liking if needed
+            map.setProjection({
+                type: ['step', ['zoom'], 'vertical-perspective', 5, 'mercator'],
+            });
+
+            if (typeof bounds != 'undefined') {
+                map.fitBounds(bounds);
+            }
+
+            mapLayers.forEach((title: string) => {
+                if (title != 'stations-layer') {
+                    smap.map.on('mouseenter', title, (e) => {
+                        smap.map.getCanvas().style.cursor = 'pointer';
+                        if (e.features == undefined) return;
+                        if (
+                            !isEventGeoJSONProperties(
+                                e.features[0].properties as any
+                            )
+                        )
+                            return;
+                        let text = JSON.parse(
+                            e.features[0].properties.description
+                        );
+                        console.log(text);
+
+                        // Pretty ugly but as we know, it'll always be a point, we can do it like this
+                        const feature = e
+                            .features![0] as geojson.Feature<geojson.Point>;
+                        const [lng, lat] = feature.geometry.coordinates;
+
+                        descPopup
+                            .setLngLat([lng, lat])
+                            .setHTML(text[lang])
+                            .addTo(smap.map);
+                    });
+                    smap.map.on('mouseleave', title, () => {
+                        descPopup.remove();
+                        smap.map.getCanvas().style.cursor = '';
+                    });
+                }
+            });
+
+            resolve(smap);
+        });
+    });
+}
+
+export function EventToEventGeoJSON(e: SisEvent): EventGeoJSON {
+    let evGeoJson: EventGeoJSON = { type: 'FeatureCollection', features: [] };
+
+    const lng: number = e.preferredOrigin.longitude;
+    const lat: number = e.preferredOrigin.latitude;
+
+    let feature: EventFeature = {
+        id: e.publicid,
+        properties: e,
+        geometry: { coordinates: [lng, lat], type: 'Point' },
+        type: 'Feature',
+    };
+
+    evGeoJson.features.push(feature);
+
+    return evGeoJson;
+}