@mapcreator/api 5.0.0-alpha.73 → 5.0.0-alpha.75

package/src/api/choropleth.ts

@@ -1,6 +1,7 @@
-import { type ApiError, type ApiSuccess, getSearchParams, request } from '../utils.js';
+import { type ApiError, type ApiSuccess, type Flatten, type Revivers, getSearchParams, request } from '../utils.js';
+
+import type { RequireAtLeastOne } from 'type-fest';
 import type { Polygon } from 'geojson';
-import { RequireAtLeastOne } from 'type-fest';
 
 export type ApiSearchPoint = {
   lat: number;
@@ -14,47 +15,54 @@ export type ApiSearchBounds = {
   max_lng: number;
 };
 
-type ApiSingleOrGroupedArea = {
-  id: number;
-  title: string;
-  subtitle: string;
-  svg_preview: string;
-  bounding_box: string;
-  is_group: boolean;
-  vector_source: string | null;
-  source_layer: string | null;
-  feature_id: number | null;
-  properties: Record<string, string> | null;
-};
-
-type ApiSingleOrGroupedAreaArray = {
-  data: ApiSingleOrGroupedArea[];
-} & Omit<ApiSuccess, 'data'> | ApiError;
-
 type SingleOrGroupedAreaBase = {
   id: number;
   title: string;
   subtitle: string;
   svgPreview: string;
   boundingBox: Polygon;
+  isGroup: boolean;
+  properties: Record<string, string> | null;
 };
 
 // TODO don't export this once search on click is out
-export type GroupedArea = SingleOrGroupedAreaBase & {
-  isGroup: true;
-};
+export type GroupedArea = SingleOrGroupedAreaBase;
 
 // TODO don't export this once search on click is out
 export type SingleArea = SingleOrGroupedAreaBase & {
-  isGroup: false;
   vectorSource: string;
   sourceLayer: string;
   featureId: number;
-  properties: Record<string, string>;
 };
 
 export type SingleOrGroupedArea = SingleArea | GroupedArea;
 
+export type ApiSingleOrGroupedArea = {
+  data: {
+    id: number;
+    title: string;
+    subtitle: string;
+    svg_preview: string;
+    bounding_box: string;
+    is_group: boolean;
+    vector_source: string | null;
+    source_layer: string | null;
+    feature_id: number | null;
+    properties: string | null;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiSingleOrGroupedAreaData = Flatten<Exclude<ApiSingleOrGroupedArea, ApiError>['data']>;
+
+export const singleOrGroupedAreaRevivers: Revivers<ApiSingleOrGroupedArea, SingleOrGroupedArea> = {
+  boundingBox: (data: ApiSingleOrGroupedAreaData) => JSON.parse(data.bounding_box) as Polygon,
+  properties: (data: ApiSingleOrGroupedAreaData) =>
+    (data.properties != null ? JSON.parse(data.properties) as Record<string, string> : null),
+};
+
+/**
+ * TODO When SAGA search on click is implemented, remove mode and make searchBounds required
+ */
 export async function searchSingleOrGroupedAreas(
   language: string,
   search: RequireAtLeastOne<{
@@ -64,43 +72,23 @@ export async function searchSingleOrGroupedAreas(
   }>,
   mode: 'polygon' | 'group' | 'both' = 'both',
 ): Promise<SingleOrGroupedArea[]> {
-  /**
-   * TODO When SAGA search on click is implemented, remove mode and make searchBounds required
-   */
-  return request<ApiSingleOrGroupedAreaArray, SingleOrGroupedArea>(
-    `/v1/choropleth/polygons/search?${getSearchParams({
-      language,
-      ...search.searchBounds,
-      ...(search.query && { query: search.query }),
-      ...(search.searchPoint && { point: search.searchPoint }),
-      mode,
-    })}`,
-  ).then(result => {
-    result.forEach(
-      elem => {
-        elem.boundingBox = JSON.parse(elem.boundingBox as unknown as string) as Polygon;
-        if (!elem.isGroup) {
-          elem.properties = JSON.parse(elem.properties as unknown as string) as Record<string, string>;
-        }
-      },
-    );
-
-    return result;
+  const pathname = '/v1/choropleth/polygons/search';
+  const query = getSearchParams({
+    language,
+    ...search.searchBounds,
+    ...(search.query && { query: search.query }),
+    ...(search.searchPoint && { point: search.searchPoint }),
+    mode,
   });
-}
+  const path = `${pathname}?${query}`;
+  const options = { revivers: singleOrGroupedAreaRevivers };
 
-type ApiGroupedAreaChild = {
-  id: number;
-  title: string;
-  vector_source: string;
-  source_layer: string;
-  feature_id: number;
-  properties: Record<string, string>;
-};
+  type ApiSingleOrGroupedAreaArray = {
+    data: ApiSingleOrGroupedAreaData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
 
-type ApiGroupedAreaChildArray = {
-  data: ApiGroupedAreaChild[];
-} & Omit<ApiSuccess, 'data'> | ApiError;
+  return request<ApiSingleOrGroupedAreaArray, SingleOrGroupedArea>(path, null, null, options);
+}
 
 export type GroupedAreaChild = {
   id: number;
@@ -108,19 +96,116 @@ export type GroupedAreaChild = {
   vectorSource: string;
   sourceLayer: string;
   featureId: number;
+  boundingBox: Polygon;
   properties: Record<string, string>;
 };
 
+type ApiGroupedAreaChild = {
+  data: {
+    id: number;
+    title: string;
+    vector_source: string;
+    source_layer: string;
+    feature_id: number;
+    bounding_box: string;
+    properties: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiGroupedAreaChildData = Flatten<Exclude<ApiGroupedAreaChild, ApiError>['data']>;
+
+export const groupedAreaChildRevivers: Revivers<ApiGroupedAreaChild, GroupedAreaChild> = {
+  boundingBox: (data: ApiGroupedAreaChildData) => JSON.parse(data.bounding_box) as Polygon,
+  properties: (data: ApiGroupedAreaChildData) => JSON.parse(data.properties) as Record<string, string>,
+};
+
 export async function groupedAreaChildren(groupId: number, language: string): Promise<GroupedAreaChild[]> {
-  return request<ApiGroupedAreaChildArray, GroupedAreaChild>(
-    `/v1/choropleth/groups/${groupId}/children-optimized?${getSearchParams({ language })}`,
-  ).then(result => {
-    result.forEach(
-      elem => {
-        elem.properties = JSON.parse(elem.properties as unknown as string) as Record<string, string>;
-      }
-    );
-
-    return result;
-  });
+  const pathname = `/v1/choropleth/groups/${groupId}/children-optimized`;
+  const query = getSearchParams({ language });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: groupedAreaChildRevivers };
+
+  type ApiApiGroupedAreaChildArray = {
+    data: ApiGroupedAreaChildData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiApiGroupedAreaChildArray, GroupedAreaChild>(path, null, null, options);
+}
+
+export type MatchedGroup = {
+  id: number;
+  sml: number;
+  childrenCount: number;
+  matchField: string;
+  property: string;
+  name: string;
+};
+
+export type ApiMatchedGroup = {
+  data: {
+    id: number;
+    sml: number;
+    children_count: number;
+    match_field: string;
+    property: string;
+    name: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiMatchedGroupData = Flatten<Exclude<ApiMatchedGroup, ApiError>['data']>;
+
+export async function getGroupsByDataSample(
+  sample: Record<string, string[]>,
+  language: string,
+): Promise<MatchedGroup[]> {
+  const path = `/v1/choropleth/groups/sample`;
+
+  type ApiMatchedGroupArray = {
+    data: ApiMatchedGroupData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiMatchedGroupArray, MatchedGroup>(path, { sample, language });
+}
+
+export type BoundPolygon = {
+  index: number;
+  id: number;
+  sml: number;
+  name: string;
+  inputName: string;
+  boundingBox: Polygon;
+};
+
+export type ApiBoundPolygon = {
+  data: {
+    index: number;
+    id: number;
+    sml: number;
+    name: string;
+    input_name: string;
+    bounding_box: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiBoundPolygonData = Flatten<Exclude<ApiBoundPolygon, ApiError>['data']>;
+
+export const boundPolygonRevivers: Revivers<ApiBoundPolygon, BoundPolygon> = {
+  boundingBox: (data: ApiBoundPolygonData) => JSON.parse(data.bounding_box) as Polygon,
+};
+
+export async function getBoundPolygons(
+  groupId: number,
+  property: string,
+  data: string[],
+  language: string,
+): Promise<BoundPolygon[]> {
+  const path = `/v1/choropleth/groups/bind`;
+  const body = { group_id: groupId, property, data, language };
+  const options = { revivers: boundPolygonRevivers };
+
+  type ApiBoundPolygonArray = {
+    data: ApiBoundPolygonData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiBoundPolygonArray, BoundPolygon>(path, body, null, options);
 }