@mapcreator/api 0.0.0-saga.1 → 0.0.0-saga.10

package/src/api/apiCommon.ts

@@ -1,70 +1,71 @@
-import { type ApiJobData, type Job, jobRevivers } from './job.js';
-import {
-  APIMeta,
-  type ApiError,
-  type ApiSuccess,
-  type Revivers,
-  defaultListHeader,
-  getSearchParams,
-  request,
-} from '../utils.js';
-
-export interface JobSearchResult {
-  pageCount: number;
-  data: Job[];
-}
-
-export async function listJobs(
-  pathname: string,
-  title: string,
-  page: number,
-  searchOptions?: Record<string, unknown>,
-): Promise<JobSearchResult> {
-  const defaultSearchOptions = {
-    sort: '-updated',
-    only_downloaded: false,
-  };
-
-  const search = { ...defaultSearchOptions, ...searchOptions };
-
-  const query = getSearchParams({
-    only_with_revisions: true,
-    search: {
-      job_type_id: '9',
-      ...(title.length > 0 && { title: `~:${title}` }),
-    },
-    ...search,
-  });
-
-  const path = `${pathname}?${query}`;
-
-  const headers = {
-    ...defaultListHeader,
-    'X-Page': `${page}`,
-  };
-  const options = {
-    revivers: jobRevivers as Revivers<ApiJobArray, Job>,
-    withMeta: true,
-  };
-
-  type ApiJobArray = {
-    data: ApiJobData[];
-  } & Omit<ApiSuccess, 'data'> | ApiError;
-
-  const result = (await request<ApiJobArray, Job>(path, null, headers, options).catch(
-    (error: Error) => {
-      if (error instanceof APIMeta) {
-        const { data, headers, status } = error as APIMeta<ApiJobArray, Job>;
-
-        return { data, headers, status };
-      }
-
-      throw error;
-    },
-  )) as APIMeta<ApiJobArray, Job>;
-
-  return {
-    data: result.data,
-    pageCount: Number(result.headers.get('X-Paginate-Pages')),
-  };
-}
+import { type ApiJobData, type Job, jobRevivers } from './job.js';
+import {
+  APIMeta,
+  type ApiError,
+  type ApiSuccess,
+  type Revivers,
+  defaultListHeader,
+  getSearchParams,
+  request,
+} from '../utils.js';
+
+export interface JobSearchResult {
+  pageCount: number;
+  data: Job[];
+}
+
+export async function listJobs(
+  pathname: string,
+  title: string,
+  page: number,
+  searchOptions?: Record<string, unknown>,
+): Promise<JobSearchResult> {
+  const defaultSearchOptions = {
+    sort: '-updated',
+    only_downloaded: false,
+  };
+
+  const search = { ...defaultSearchOptions, ...searchOptions };
+
+  const query = getSearchParams({
+    only_with_revisions: true,
+    search: {
+      job_type_id: ['9', '6'],
+      converted_job_id: '=:',
+      ...(title.length > 0 && { title: `~:${title}` }),
+    },
+    ...search,
+  });
+
+  const path = `${pathname}?${query}`;
+
+  const headers = {
+    ...defaultListHeader,
+    'X-Page': `${page}`,
+  };
+  const options = {
+    revivers: jobRevivers as Revivers<ApiJobArray, Job>,
+    withMeta: true,
+  };
+
+  type ApiJobArray = {
+    data: ApiJobData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  const result = (await request<ApiJobArray, Job>(path, null, headers, options).catch(
+    (error: Error) => {
+      if (error instanceof APIMeta) {
+        const { data, headers, status } = error as APIMeta<ApiJobArray, Job>;
+
+        return { data, headers, status };
+      }
+
+      throw error;
+    },
+  )) as APIMeta<ApiJobArray, Job>;
+
+  return {
+    data: result.data,
+    pageCount: Number(result.headers.get('X-Paginate-Pages')),
+  };
+}

package/src/api/choropleth.ts

@@ -1,105 +1,256 @@
-import { type ApiError, type ApiSuccess, getSearchParams, request } from '../utils.js';
-import type { Polygon } from 'geojson';
-
-export type ApiSearchPoint = {
-  lat: number;
-  lng: number;
-};
-
-export type ApiSearchBounds = {
-  min_lat: number;
-  min_lng: number;
-  max_lat: number;
-  max_lng: number;
-};
-
-type ApiSingleOrGroupedAreaArray =
-  | ({ data: ApiSingleOrGroupedArea[] } & Omit<ApiSuccess, 'data'>)
-  | ApiError;
-
-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 SingleOrGroupedAreaBase = {
-  id: number;
-  title: string;
-  subtitle: string;
-  svgPreview: string;
-  boundingBox: Polygon;
-};
-
-type GroupedArea = SingleOrGroupedAreaBase & {
-  isGroup: true;
-};
-
-type SingleArea = SingleOrGroupedAreaBase & {
-  isGroup: false;
-  vectorSource: string;
-  sourceLayer: string;
-  featureId: number;
-  properties: Record<string, string>;
-};
-
-export type SingleOrGroupedArea = SingleArea | GroupedArea;
-
-export async function searchSingleOrGroupedAreas(
-  language: string,
-  searchBounds: ApiSearchBounds,
-  query?: string,
-  searchPoint?: ApiSearchPoint,
-): Promise<SingleOrGroupedArea[]> {
-  return request<ApiSingleOrGroupedAreaArray, SingleOrGroupedArea>(
-    `/v1/choropleth/polygons/search?${getSearchParams({
-      language,
-      ...searchBounds,
-      ...(query !== '' && { query }),
-      ...(searchPoint && { point: searchPoint }),
-    })}`,
-  ).then(result => {
-    result.forEach(
-      elem => (elem.boundingBox = JSON.parse(elem.boundingBox as unknown as string) as Polygon),
-    );
-
-    return result;
-  });
-}
-
-type ApiGroupedAreaChildArray =
-  | ({
-    data: ApiGroupedAreaChild[];
-  } & Omit<ApiSuccess, 'data'>)
-  | ApiError;
-
-type ApiGroupedAreaChild = {
-  id: number;
-  title: string;
-  vector_source: string;
-  source_layer: string;
-  feature_id: number;
-  properties: Record<string, string>;
-};
-
-export type GroupedAreaChild = {
-  id: number;
-  title: string;
-  vectorSource: string;
-  sourceLayer: string;
-  featureId: number;
-  properties: 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 })}`,
-  );
-}
+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';
+
+export const boundingBoxRevivers: Revivers<
+  { data: { bounding_box: string } } & Omit<ApiSuccess, 'data'> | ApiError,
+  { boundingBox: Polygon }
+> = {
+  boundingBox: (data: { bounding_box: string }) => JSON.parse(data.bounding_box) as Polygon,
+};
+
+export type ApiSearchPoint = {
+  lat: number;
+  lng: number;
+};
+
+export type ApiSearchBounds = {
+  min_lat: number;
+  min_lng: number;
+  max_lat: number;
+  max_lng: number;
+};
+
+type SingleOrGroupedAreaBase = {
+  id: number;
+  title: string;
+  subtitle: string;
+  svgPreview: string;
+  boundingBox: Polygon;
+};
+
+export type GroupedArea = SingleOrGroupedAreaBase & {
+  isGroup: true;
+};
+
+export type SingleArea = SingleOrGroupedAreaBase & {
+  isGroup: false;
+  properties: Record<string, string>;
+  vectorSource: string;
+  sourceLayer: string;
+  featureId: number;
+};
+
+type ApiSingleArea = {
+  data: {
+    id: number;
+    title: string;
+    subtitle: string;
+    svg_preview: string;
+    bounding_box: string;
+    is_group: false;
+    properties: string;
+    vector_source: string;
+    source_layer: string;
+    feature_id: number;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiSingleAreaData = Flatten<Exclude<ApiSingleArea, ApiError>['data']>;
+
+export type ApiSingleAreaArray = {
+  data: ApiSingleAreaData[];
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+type ApiGroupedArea = {
+  data: {
+    id: number;
+    title: string;
+    subtitle: string;
+    svg_preview: string;
+    bounding_box: string;
+    is_group: true;
+    properties: null;
+    vector_source: null;
+    source_layer: null;
+    feature_id: null;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiGroupedAreaData = Flatten<Exclude<ApiGroupedArea, ApiError>['data']>;
+
+export type ApiGroupedAreaArray = {
+  data: ApiGroupedAreaData[];
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export const singleAreaRevivers: Revivers<ApiSingleArea, SingleArea> = {
+  ...boundingBoxRevivers,
+  properties: (data: ApiSingleAreaData) =>
+    JSON.parse(data.properties) as Record<string, string>,
+};
+
+export const groupedAreaRevivers: Revivers<ApiGroupedArea, GroupedArea> = {
+  ...boundingBoxRevivers,
+};
+
+export async function searchSingleAreas(
+  language: string,
+  search: RequireAtLeastOne<{
+    searchBounds: ApiSearchBounds;
+    query?: string;
+    searchPoint?: ApiSearchPoint;
+  }>,
+): Promise<SingleArea[]> {
+  const pathname = '/v1/choropleth/polygons/search';
+  const query = getSearchParams({
+    language,
+    ...search.searchBounds,
+    ...(search.query && { query: search.query }),
+    ...(search.searchPoint && { point: search.searchPoint }),
+    mode: 'polygon',
+  });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: singleAreaRevivers };
+
+  return request<ApiSingleAreaArray, SingleArea>(path, null, null, options);
+}
+
+export async function searchGroupedAreas(
+  language: string,
+  search: RequireAtLeastOne<{
+    searchBounds: ApiSearchBounds;
+    query?: string;
+    searchPoint?: ApiSearchPoint;
+  }>,
+): Promise<GroupedArea[]> {
+  const pathname = '/v1/choropleth/polygons/search';
+  const query = getSearchParams({
+    language,
+    ...search.searchBounds,
+    ...(search.query && { query: search.query }),
+    ...(search.searchPoint && { point: search.searchPoint }),
+    mode: 'group',
+  });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: groupedAreaRevivers };
+
+  return request<ApiGroupedAreaArray, GroupedArea>(path, null, null, options);
+}
+
+export type GroupedAreaChild = {
+  id: number;
+  title: string;
+  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> = {
+  ...boundingBoxRevivers,
+  properties: (data: ApiGroupedAreaChildData) => JSON.parse(data.properties) as Record<string, string>,
+};
+
+export async function groupedAreaChildren(groupId: number, language: string): Promise<GroupedAreaChild[]> {
+  const pathname = `/v1/choropleth/groups/${groupId}/children-optimized`;
+  const query = getSearchParams({ language });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: groupedAreaChildRevivers };
+
+  type ApiGroupedAreaChildArray = {
+    data: ApiGroupedAreaChildData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiGroupedAreaChildArray, GroupedAreaChild>(path, null, null, options);
+}
+
+export type MatchedGroup = {
+  id: number;
+  sml: number;
+  childrenCount: number;
+  matchField: string;
+  boundingBox: Polygon;
+  property: string;
+  name: string;
+};
+
+export type ApiMatchedGroup = {
+  data: {
+    id: number;
+    sml: number;
+    children_count: number;
+    match_field: string;
+    bounding_box: 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,
+  rowCount: number,
+): Promise<MatchedGroup[]> {
+  const path = `/v1/choropleth/groups/sample`;
+  const options = { revivers: boundingBoxRevivers };
+
+  type ApiMatchedGroupArray = {
+    data: ApiMatchedGroupData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiMatchedGroupArray, MatchedGroup>(path, { sample, language, row_count: rowCount }, null, options);
+}
+
+export type BoundPolygon = {
+  index: number;
+  inputName: string;
+  id: number;
+  sml: number;
+  name: string;
+};
+
+export type ApiBoundPolygon = {
+  data: {
+    index: number;
+    input_name: string;
+    id: number;
+    sml: number;
+    name: string;
+  };
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiBoundPolygonData = Flatten<Exclude<ApiBoundPolygon, ApiError>['data']>;
+
+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 };
+
+  type ApiBoundPolygonArray = {
+    data: ApiBoundPolygonData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiBoundPolygonArray, BoundPolygon>(path, body);
+}

package/src/api/color.ts

@@ -1,22 +1,22 @@
-import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
-
-export type Color = {
-  id: number;
-  hex: string;
-};
-
-export type ApiColor = {
-  data: {
-    id: number;                 // The color id (sortable)
-    name: string;               // The name of the color (searchable, sortable)
-    hex: string;                // The hex value of the color (searchable, sortable)
-    order?: number;             // TODO: not present in API specification!
-  } & ApiCommonData;
-} & Omit<ApiSuccess, 'data'> | ApiError;
-
-export type ApiColorData = Flatten<Exclude<ApiColor, ApiError>['data']>;
-
-export const colorRevivers: Revivers<ApiColor, Color> = {
-  name: undefined,
-  order: undefined,
-};
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type Color = {
+  id: number;
+  hex: string;
+};
+
+export type ApiColor = {
+  data: {
+    id: number;                 // The color id (sortable)
+    name: string;               // The name of the color (searchable, sortable)
+    hex: string;                // The hex value of the color (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiColorData = Flatten<Exclude<ApiColor, ApiError>['data']>;
+
+export const colorRevivers: Revivers<ApiColor, Color> = {
+  name: undefined,
+  order: undefined,
+};

package/src/api/dimension.ts

@@ -1,44 +1,44 @@
-import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
-
-export type OutputUnit =
-  | 'millimeter'
-  | 'centimeter'
-  | 'inch'
-  | 'pixel'
-  | 'pica';
-
-export type Dimension = {
-  id: number;
-  dimensionSetId: number;
-  name: string;
-  width: number;
-  height: number;
-  dpi: number;
-  unit: OutputUnit;
-};
-
-export type ApiDimension = {
-  data: {
-    id: number;                 // The dimension id (sortable)
-    dimension_set_id: number;   // The id of the dimension set
-    name: string;               // The name of dimension (searchable, sortable)
-    width: number;              // The width of the dimension (searchable, sortable)
-    height: number;             // The height of the dimension (searchable, sortable)
-    dpi: number;                // The dpi of the dimension
-    unit: string;               // The unit of this dimension
-  } & ApiCommonData;
-} & Omit<ApiSuccess, 'data'> | ApiError;
-
-export type ApiDimensionData = Flatten<Exclude<ApiDimension, ApiError>['data']>;
-
-const keyToUnit: { [key: string]: OutputUnit } = {
-  MM: 'millimeter',
-  CM: 'centimeter',
-  IN: 'inch',
-  PX: 'pixel',
-  PICA: 'pica',
-};
-
-export const dimensionRevivers: Revivers<ApiDimension, Dimension> = {
-  unit: (data: ApiDimensionData) => keyToUnit[data.unit],
-};
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type OutputUnit =
+  | 'millimeter'
+  | 'centimeter'
+  | 'inch'
+  | 'pixel'
+  | 'pica';
+
+export type Dimension = {
+  id: number;
+  dimensionSetId: number;
+  name: string;
+  width: number;
+  height: number;
+  dpi: number;
+  unit: OutputUnit;
+};
+
+export type ApiDimension = {
+  data: {
+    id: number;                 // The dimension id (sortable)
+    dimension_set_id: number;   // The id of the dimension set
+    name: string;               // The name of dimension (searchable, sortable)
+    width: number;              // The width of the dimension (searchable, sortable)
+    height: number;             // The height of the dimension (searchable, sortable)
+    dpi: number;                // The dpi of the dimension
+    unit: string;               // The unit of this dimension
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiDimensionData = Flatten<Exclude<ApiDimension, ApiError>['data']>;
+
+const keyToUnit: { [key: string]: OutputUnit } = {
+  MM: 'millimeter',
+  CM: 'centimeter',
+  IN: 'inch',
+  PX: 'pixel',
+  PICA: 'pica',
+};
+
+export const dimensionRevivers: Revivers<ApiDimension, Dimension> = {
+  unit: (data: ApiDimensionData) => keyToUnit[data.unit],
+};

package/src/api/dimensionSet.ts

@@ -1,20 +1,20 @@
-import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
-
-export type DimensionSet = {
-  id: number;
-  name: string;
-};
-
-export type ApiDimensionSet = {
-  data: {
-    id: number;                 // The dimension set id (sortable)
-    name: string;               // The dimension set name (searchable, sortable)
-    order?: number;             // TODO: not present in API specification!
-  } & ApiCommonData;
-} & Omit<ApiSuccess, 'data'> | ApiError;
-
-export type ApiDimensionSetData = Flatten<Exclude<ApiDimensionSet, ApiError>['data']>;
-
-export const dimensionSetRevivers: Revivers<ApiDimensionSet, DimensionSet> = {
-  order: undefined,
-};
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type DimensionSet = {
+  id: number;
+  name: string;
+};
+
+export type ApiDimensionSet = {
+  data: {
+    id: number;                 // The dimension set id (sortable)
+    name: string;               // The dimension set name (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiDimensionSetData = Flatten<Exclude<ApiDimensionSet, ApiError>['data']>;
+
+export const dimensionSetRevivers: Revivers<ApiDimensionSet, DimensionSet> = {
+  order: undefined,
+};