@geo2france/api-dashboard 1.5.0

package/dist/components/NextPrevSelect/NextPrevSelect.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CaretLeftOutlined, CaretRightOutlined } from "@ant-design/icons";
+import { Button, ConfigProvider, Flex, Form, Select } from "antd";
+import { useEffect, useState } from "react";
+import { list_to_options } from '../Control/Control';
+// Update field and trigger form OnValueChange, thanks to : https://github.com/ant-design/ant-design/issues/23782#issuecomment-2114700558
+const updateFieldValue = (form, name, value) => {
+    form.getInternalHooks('RC_FORM_INTERNAL_HOOKS').dispatch({
+        type: 'updateValue',
+        namePath: [name],
+        value: value
+    });
+};
+const style_button_left = {
+    borderRadius: 0,
+    borderTopLeftRadius: 4,
+    borderBottomLeftRadius: 4,
+    borderRight: 0,
+};
+const style_button_right = {
+    borderRadius: 0,
+    borderTopRightRadius: 4,
+    borderBottomRightRadius: 4,
+    borderLeft: 0,
+};
+const NextPrevSelect = ({ name, options: input_options = [], style, value, defaultValue, onChange, reverse = false, arrows = true, ...rest }) => {
+    const [current_value, setCurrent_value] = useState(value);
+    const form = Form.useFormInstance();
+    useEffect(() => {
+        setCurrent_value(value);
+    }, [value]);
+    const options = list_to_options(input_options);
+    const current_index = options?.findIndex((o) => o.value == form?.getFieldValue(name) || o.value == current_value);
+    const next = () => reverse
+        ? options[current_index - 1].value
+        : options[current_index + 1].value;
+    const previous = () => reverse
+        ? options[current_index + 1].value
+        : options[current_index - 1].value;
+    const isFirst = () => reverse ? current_index == options.length - 1 : current_index == 0;
+    const isLast = () => reverse ? current_index == 0 : current_index == options.length - 1;
+    const handleChange = (v) => {
+        setCurrent_value(v);
+        name && form && updateFieldValue(form, name, v);
+        onChange && onChange(v);
+    };
+    return (_jsxs(Flex, { style: style, name: name, children: [arrows && _jsx(Button, { style: style_button_left, onClick: () => handleChange(previous()), disabled: isFirst(), children: _jsx(CaretLeftOutlined, {}) }), _jsxs(ConfigProvider, { theme: arrows ? { components: { Select: { borderRadius: 0, }, }, } : undefined, children: [" ", _jsx(Form.Item, { name: name, label: name, noStyle: arrows, initialValue: defaultValue, shouldUpdate: true, children: _jsx(Select, { className: "nextPrevSelect", options: options, style: { ...style }, value: current_value, defaultValue: defaultValue, onChange: handleChange, ...rest }) })] }), arrows && _jsx(Button, { style: style_button_right, onClick: () => handleChange(next()), disabled: isLast(), children: _jsx(CaretRightOutlined, {}) })] }));
+};
+export default NextPrevSelect;

package/dist/components/Palette/Palette.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_PALETTE: PaletteType;
+type PaletteModeType = 'rgb' | 'hsl' | 'lab' | 'lrgb' | 'lch';
+export interface PaletteType {
+    steps?: string[];
+    mode?: PaletteModeType;
+}
+type PaletteContextType = {
+    palette: PaletteType;
+    setPalette: (p: PaletteType) => void;
+};
+export declare const PaletteContext: import("react").Context<PaletteContextType | undefined>;
+interface UsePaletteProps {
+    nColors?: number;
+}
+export declare const usePalette: ({ nColors }: UsePaletteProps) => string[] | undefined;
+export declare const Palette: React.FC<PaletteType>;
+export declare const PalettePreview: React.FC;
+export {};

package/dist/components/Palette/Palette.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Tag } from "antd";
+import chroma from "chroma-js";
+import { createContext, useContext, useEffect } from "react";
+export const DEFAULT_PALETTE = { steps: ['red', 'green', 'blue'], mode: 'hsl' };
+export const PaletteContext = createContext({ palette: DEFAULT_PALETTE, setPalette: () => { } });
+export const usePalette = ({ nColors }) => {
+    const palette_context = useContext(PaletteContext);
+    const palette_info = palette_context?.palette;
+    if (nColors === undefined) {
+        return undefined;
+    }
+    return palette_info?.steps && chroma.scale(palette_info.steps).mode(palette_info.mode || 'hsl').colors(nColors);
+};
+/*
+* Composant permettant à l'utilisateur de définir une palette pour sa page
+*/
+export const Palette = ({ steps, mode }) => {
+    const palette = { steps, mode };
+    const palette_context = useContext(PaletteContext);
+    useEffect(() => {
+        palette_context?.setPalette(palette);
+    }, [steps]);
+    return null;
+};
+export const PalettePreview = ({}) => {
+    const colors = usePalette({ nColors: 10 }) || [];
+    return (_jsx(_Fragment, { children: colors.map((color) => (_jsx(Tag, { color: color, children: color }, color))) }));
+};

package/dist/data_providers/datafair/datafair.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/data_providers/datafair/datafair.test.js

@@ -0,0 +1,39 @@
+import '@testing-library/jest-dom';
+import { QueryClient } from '@tanstack/react-query';
+import { DatafairProvider } from '../..';
+const test_provider_url = "https://data.ademe.fr/data-fair/api/v1/datasets";
+const test_page_size = 3;
+const test_filter_field = "L_TYP_REG_SERVICE";
+const test_filter_value = "Valorisation organique";
+const resource = "sinoe-(r)-destination-des-dma-collectes-par-type-de-traitement/lines";
+const filters = [
+    {
+        field: test_filter_field,
+        operator: "eq",
+        value: test_filter_value,
+    },
+];
+const pagination = {
+    mode: "server",
+    pageSize: test_page_size,
+};
+const sorters = undefined;
+const queryClient = new QueryClient();
+describe("DataFair Provider", () => {
+    test("basic filter & pagination", async () => {
+        const provider = DatafairProvider(test_provider_url);
+        const queryKey = [provider.getApiUrl, resource, filters, pagination, sorters, undefined];
+        const result = await queryClient.fetchQuery({
+            queryKey: queryKey,
+            queryFn: () => provider.getList({
+                resource: resource,
+                filters: filters,
+                pagination: pagination,
+                sorters: sorters
+            }),
+        });
+        expect(result).toHaveProperty('data');
+        expect(result.data).toHaveLength(test_page_size);
+        expect(result.data[0][test_filter_field]).toEqual(test_filter_value);
+    });
+});

package/dist/data_providers/datafair/index.d.ts

@@ -0,0 +1,15 @@
+import { AxiosInstance } from "axios";
+export interface GetListParams {
+    resource: string;
+    pagination?: any;
+    filters?: any[];
+    sorters?: any[];
+    meta?: any;
+}
+export declare const dataProvider: (apiUrl: string, httpClient?: AxiosInstance) => {
+    getList: ({ resource, pagination, filters, sorters, meta }: GetListParams) => Promise<{
+        data: any;
+        total: any;
+    }>;
+    getApiUrl: () => string;
+};

package/dist/data_providers/datafair/index.js

@@ -0,0 +1,33 @@
+import { axiosInstance, generateSort, generateFilter } from "./utils";
+import queryString from "query-string";
+export const dataProvider = (apiUrl, httpClient = axiosInstance) => ({
+    getList: async ({ resource, pagination, filters, sorters, meta }) => {
+        const url = `${apiUrl}/${resource}`; //Ajouter /line par défaut ? (si aucun autre /machin)
+        const { current = 1, pageSize = 10, mode = "server" } = pagination ?? {};
+        const { headers: headersFromMeta, method } = meta ?? {};
+        const requestMethod = method ?? "get";
+        const queryFilters = generateFilter(filters);
+        const query = {};
+        if (mode === "server") {
+            query.page = current;
+            query.size = pageSize;
+        }
+        const generatedSort = generateSort(sorters);
+        if (generatedSort) {
+            query.sort = generatedSort;
+        }
+        if (queryFilters) {
+            query.qs = queryFilters;
+        }
+        const { data } = await httpClient[requestMethod](`${url}?${queryString.stringify(query)}`, {
+            headers: headersFromMeta,
+        });
+        return {
+            data: data.results,
+            total: data.total,
+        };
+    },
+    getApiUrl: () => {
+        return apiUrl;
+    },
+});

package/dist/data_providers/datafair/utils/axios.d.ts

@@ -0,0 +1,2 @@
+declare const axiosInstance: import("axios").AxiosInstance;
+export { axiosInstance };

package/dist/data_providers/datafair/utils/axios.js

@@ -0,0 +1,13 @@
+import axios from "axios";
+const axiosInstance = axios.create();
+axiosInstance.interceptors.response.use((response) => {
+    return response;
+}, (error) => {
+    const customError = {
+        ...error,
+        message: error.response?.data?.message,
+        statusCode: error.response?.status,
+    };
+    return Promise.reject(customError);
+});
+export { axiosInstance };

package/dist/data_providers/datafair/utils/generateFilter.d.ts

@@ -0,0 +1 @@
+export declare const generateFilter: (filters?: any[]) => string;

package/dist/data_providers/datafair/utils/generateFilter.js

@@ -0,0 +1,40 @@
+export const generateFilter = (filters) => {
+    const array_filter = [];
+    if (filters) {
+        filters.map((filter) => {
+            if (filter.operator !== "or" && filter.operator !== "and" && "field" in filter) { // LogicalFilter
+                const value = (() => {
+                    switch (filter.operator) {
+                        case "contains":
+                            return filter.value;
+                        case "eq":
+                        case "ne":
+                            return `"${filter.value}"`;
+                        case "startswith":
+                            return `${filter.value}*`;
+                        case "endswith":
+                            return `*${filter.value}`;
+                        case "in":
+                            return filter.value.join(' ');
+                    }
+                })();
+                const not = (() => {
+                    switch (filter.operator) {
+                        case "ne":
+                        case "nstartswith":
+                        case "nendswith":
+                        case "nin":
+                            return 'NOT ';
+                        default:
+                            return '';
+                    }
+                })();
+                array_filter.push(`(${not}${filter.field}:${value})`);
+            }
+            else { //Conditionnal filter
+                throw new Error(`[datafair-data-provider]: Condtionnal filter 'OR' not implemented yet `);
+            }
+        });
+    }
+    return array_filter.join(' AND ');
+};

package/dist/data_providers/datafair/utils/generateSort.d.ts

@@ -0,0 +1 @@
+export declare const generateSort: (sorters?: any[]) => string | undefined;

package/dist/data_providers/datafair/utils/generateSort.js

@@ -0,0 +1,19 @@
+export const generateSort = (sorters) => {
+    if (sorters && sorters.length > 0) {
+        const _sort = [];
+        sorters.map((item) => {
+            const order = (() => {
+                switch (item.order) {
+                    case 'desc':
+                        return '-';
+                    case 'asc':
+                    default:
+                        return '';
+                }
+            })();
+            _sort.push(`${order}${item.field}`);
+        });
+        return _sort.join(',');
+    }
+    return;
+};

package/dist/data_providers/datafair/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { mapOperator } from "./mapOperator";
+export { generateSort } from "./generateSort";
+export { generateFilter } from "./generateFilter";
+export { axiosInstance } from "./axios";

package/dist/data_providers/datafair/utils/index.js

@@ -0,0 +1,4 @@
+export { mapOperator } from "./mapOperator";
+export { generateSort } from "./generateSort";
+export { generateFilter } from "./generateFilter";
+export { axiosInstance } from "./axios";

package/dist/data_providers/datafair/utils/mapOperator.d.ts

@@ -0,0 +1 @@
+export declare const mapOperator: (operator: any) => string;

package/dist/data_providers/datafair/utils/mapOperator.js

@@ -0,0 +1,13 @@
+export const mapOperator = (operator) => {
+    switch (operator) {
+        case "ne":
+        case "gte":
+        case "lte":
+            return `_${operator}`;
+        case "contains":
+            return "_like";
+        case "eq":
+        default:
+            return "";
+    }
+};

package/dist/data_providers/file/index.d.ts

@@ -0,0 +1,6 @@
+import { AxiosInstance } from "axios";
+import { DataProvider } from "../types";
+export declare const dataProvider: (apiUrl: string, options?: {
+    httpClient?: AxiosInstance;
+    processData?: (data: any) => any[];
+}) => DataProvider;

package/dist/data_providers/file/index.js

@@ -0,0 +1,25 @@
+import { axiosInstance } from "./utils/axios";
+// Ajouter la possibilite de passer au provider une fonction pour parser le résultat (ex : (e) => e.result)
+export const dataProvider = (apiUrl, options) => {
+    const { httpClient = axiosInstance, processData } = options || {};
+    return {
+        getList: async ({ resource, pagination, filters, sorters, meta }) => {
+            const url = `${apiUrl}/${resource}`; // (ressource = url + nom du fichier + extension)
+            const { headers: headersFromMeta, method } = meta ?? {};
+            const requestMethod = method ?? "get";
+            const { data, headers: _headers } = await httpClient[requestMethod](`${url}`, {
+                headers: headersFromMeta,
+            });
+            const out_data = processData ? processData(data) : data;
+            //const features = //papaparse data
+            return {
+                data: out_data, //Parser ici avec la fonction utilisateur
+                total: out_data.length,
+                // Ajouter le fichier brut ?
+            };
+        },
+        getApiUrl: () => {
+            return apiUrl;
+        },
+    };
+};

package/dist/data_providers/file/utils/axios.d.ts

@@ -0,0 +1,2 @@
+declare const axiosInstance: import("axios").AxiosInstance;
+export { axiosInstance };

package/dist/data_providers/file/utils/axios.js

@@ -0,0 +1,26 @@
+import axios from "axios";
+const axiosInstance = axios.create();
+axiosInstance.interceptors.response.use(
+// API WFS retourne toujours un code http 200, y compris en cas d'erreur.
+// Une réponse est présumée valide si elle renvoie un objet json valide. (Sinon c'est un xml)
+// TODO parser le XML retourné en cas d'erreur
+(response) => {
+    if (typeof response.data === "object") {
+        return response;
+    }
+    else {
+        const customError = {
+            message: response.data,
+            statusCode: response.status,
+        };
+        return Promise.reject(customError);
+    }
+}, (error) => {
+    const customError = {
+        ...error,
+        message: error.response?.data?.message,
+        statusCode: error.response?.status,
+    };
+    return Promise.reject(customError);
+});
+export { axiosInstance };

package/dist/data_providers/types.d.ts

@@ -0,0 +1,52 @@
+export interface Pagination {
+    /**
+     * Initial page index
+     * @default 1
+     */
+    current?: number;
+    /**
+     * Initial number of items per page
+     * @default 10
+     */
+    pageSize?: number;
+    /**
+     * Whether to use server side pagination or not.
+     * @default "server"
+     */
+    mode?: "client" | "server" | "off";
+}
+export type CrudOperators = "eq" | "ne" | "lt" | "gt" | "lte" | "gte" | "in" | "nin" | "ina" | "nina" | "contains" | "ncontains" | "containss" | "ncontainss" | "between" | "nbetween" | "null" | "nnull" | "startswith" | "nstartswith" | "startswiths" | "nstartswiths" | "endswith" | "nendswith" | "endswiths" | "nendswiths" | "or" | "and";
+export type SortOrder = "desc" | "asc" | null;
+export type LogicalFilter = {
+    field: string;
+    operator: Exclude<CrudOperators, "or" | "and">;
+    value: any;
+};
+export type ConditionalFilter = {
+    key?: string;
+    operator: Extract<CrudOperators, "or" | "and">;
+    value: (LogicalFilter | ConditionalFilter)[];
+};
+export type CrudFilter = LogicalFilter | ConditionalFilter;
+export type CrudSort = {
+    field: string;
+    order: "asc" | "desc";
+};
+export type CrudFilters = CrudFilter[];
+export type CrudSorting = CrudSort[];
+export interface GetListResponse {
+    data: any[];
+    total: number;
+    geojson?: any;
+    [key: string]: any;
+}
+export interface DataProvider {
+    getApiUrl: () => string;
+    getList: (params: {
+        resource: string;
+        filters?: CrudFilters;
+        pagination?: Pagination;
+        sorters?: CrudSorting;
+        meta?: any;
+    }) => Promise<GetListResponse>;
+}

package/dist/data_providers/types.js

@@ -0,0 +1,2 @@
+// Types from Refinedev
+export {};

package/dist/data_providers/wfs/index.d.ts

@@ -0,0 +1,3 @@
+import { AxiosInstance } from "axios";
+import { DataProvider } from "../types";
+export declare const dataProvider: (apiUrl: string, httpClient?: AxiosInstance) => DataProvider;

package/dist/data_providers/wfs/index.js

@@ -0,0 +1,43 @@
+import { axiosInstance, generateSort, generateFilter } from "./utils";
+import queryString from "query-string";
+export const dataProvider = (apiUrl, httpClient = axiosInstance) => ({
+    getList: async ({ resource, pagination, filters, sorters, meta }) => {
+        const url = `${apiUrl}/`;
+        const { current = 1, pageSize = 10, mode = "off" } = pagination ?? {};
+        const { headers: headersFromMeta, method } = meta ?? {};
+        const requestMethod = method ?? "get";
+        const { cql_filter: queryFilters, bbox } = generateFilter(filters);
+        const generatedSort = generateSort(sorters);
+        const query = { service: 'WFS', request: 'GetFeature', sortby: '', version: '2.0.0', outputformat: 'application/json', typenames: resource,
+            srsname: meta?.srsname, propertyname: meta?.properties?.join(',') };
+        if (mode === "server") {
+            query.startindex = (current - 1) * pageSize;
+            query.count = pageSize;
+        }
+        if (generatedSort) {
+            query.sortby = generatedSort;
+        }
+        if (queryFilters) {
+            query.cql_filter = queryFilters;
+        }
+        if (bbox !== '') {
+            query.bbox = bbox;
+        }
+        const { data, headers: _headers } = await httpClient[requestMethod](`${url}?${queryString.stringify({ ...query, sortby: undefined })}&sortby=${query.sortby}&`, //"le + de sortby ne doit pas être urlencode"
+        {
+            headers: headersFromMeta,
+        });
+        const features = data.features.map((feature) => {
+            const { properties, type, ...rest } = feature; //Remonter d'un niveau les properties, supprimer root.type
+            return { ...rest, ...properties };
+        });
+        return {
+            data: features,
+            geojson: data,
+            total: data.numberMatched,
+        };
+    },
+    getApiUrl: () => {
+        return apiUrl;
+    },
+});

package/dist/data_providers/wfs/utils/axios.d.ts

@@ -0,0 +1,2 @@
+declare const axiosInstance: import("axios").AxiosInstance;
+export { axiosInstance };

package/dist/data_providers/wfs/utils/axios.js

@@ -0,0 +1,26 @@
+import axios from "axios";
+const axiosInstance = axios.create();
+axiosInstance.interceptors.response.use(
+// API WFS retourne toujours un code http 200, y compris en cas d'erreur.
+// Une réponse est présumée valide si elle renvoie un objet json valide. (Sinon c'est un xml)
+// TODO parser le XML retourné en cas d'erreur
+(response) => {
+    if (typeof response.data === "object") {
+        return response;
+    }
+    else {
+        const customError = {
+            message: response.data,
+            statusCode: response.status,
+        };
+        return Promise.reject(customError);
+    }
+}, (error) => {
+    const customError = {
+        ...error,
+        message: error.response?.data?.message,
+        statusCode: error.response?.status,
+    };
+    return Promise.reject(customError);
+});
+export { axiosInstance };

package/dist/data_providers/wfs/utils/generateFilter.d.ts

@@ -0,0 +1,4 @@
+export declare const generateFilter: (filters?: any[]) => {
+    cql_filter: string;
+    bbox: string;
+};

package/dist/data_providers/wfs/utils/generateFilter.js

@@ -0,0 +1,45 @@
+import { mapOperator } from "./mapOperator";
+export const generateFilter = (filters) => {
+    const array_filter = [];
+    let bbox = '';
+    if (filters) {
+        filters.map((filter) => {
+            if (filter.operator !== "or" && filter.operator !== "and" && "field" in filter) { // LogicalFilter
+                const mappedOperator = mapOperator(filter.operator);
+                if (filter.field === "geometry") {
+                    bbox = filter.value;
+                }
+                else {
+                    const value = (() => {
+                        switch (filter.operator) {
+                            case "contains":
+                            case "containss":
+                            case "ncontains":
+                            case "ncontainss":
+                                return `'%${filter.value}%'`;
+                            case "startswith":
+                            case "startswiths":
+                            case "nstartswith":
+                            case "nstartswiths":
+                                return `'${filter.value}%'`;
+                            case "endswith":
+                            case "endswiths":
+                            case "nendswith":
+                            case "nendswiths":
+                                return `'%${filter.value}'`;
+                            case "in":
+                                return `(${filter.value.map((i) => `'${i}'`).join(',')})`;
+                            default:
+                                return `'${filter.value}'`;
+                        }
+                    })();
+                    array_filter.push(`${filter.field} ${mappedOperator} ${value}`);
+                }
+            }
+            else { //Conditionnal filter
+                throw new Error(`[wfs-data-provider]: Condtionnal filter 'OR' not implemented yet `);
+            }
+        });
+    }
+    return { cql_filter: array_filter.join(' and '), bbox: bbox };
+};

package/dist/data_providers/wfs/utils/generateSort.d.ts

@@ -0,0 +1 @@
+export declare const generateSort: (sorters?: any[]) => string | undefined;

package/dist/data_providers/wfs/utils/generateSort.js

@@ -0,0 +1,20 @@
+export const generateSort = (sorters) => {
+    if (sorters && sorters.length > 0) {
+        const _sort = [];
+        sorters.map((item) => {
+            const order = (() => {
+                switch (item.order) {
+                    case 'asc':
+                        return 'A';
+                    case 'desc':
+                        return 'D';
+                    default:
+                        return 'A';
+                }
+            })();
+            _sort.push(`${item.field}+${order}`);
+        });
+        return _sort.join(',');
+    }
+    return;
+};

package/dist/data_providers/wfs/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { mapOperator } from "./mapOperator";
+export { generateSort } from "./generateSort";
+export { generateFilter } from "./generateFilter";
+export { axiosInstance } from "./axios";

package/dist/data_providers/wfs/utils/index.js

@@ -0,0 +1,4 @@
+export { mapOperator } from "./mapOperator";
+export { generateSort } from "./generateSort";
+export { generateFilter } from "./generateFilter";
+export { axiosInstance } from "./axios";

package/dist/data_providers/wfs/utils/mapOperator.d.ts

@@ -0,0 +1 @@
+export declare const mapOperator: (operator: any) => string;

package/dist/data_providers/wfs/utils/mapOperator.js

@@ -0,0 +1,36 @@
+export const mapOperator = (operator) => {
+    switch (operator) {
+        case "ne":
+            return '<>';
+        case "gte":
+            return '>=';
+        case "gt":
+            return '>';
+        case "lte":
+            return `<=`;
+        case "lt":
+            return `<`;
+        case "eq":
+            return "=";
+        case "contains":
+        case "startswith":
+        case "endswith":
+            return "ilike";
+        case "containss":
+        case "startswiths":
+        case "endswiths":
+            return "like";
+        case "ncontains":
+        case "nstartswith":
+        case "nendswith":
+            return "not ilike";
+        case "ncontainss":
+        case "nstartswiths":
+        case "nendswiths":
+            return "not like";
+        case "in":
+            return operator;
+        default:
+            return "";
+    }
+};

package/dist/data_providers/wfs/wfs.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';