@mapcreator/api 3.3.1 → 5.0.0-alpha.12

package/src/api/apiCommon.ts

@@ -0,0 +1,70 @@
+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')),
+  };
+}

package/src/api/choropleth.ts

@@ -0,0 +1,318 @@
+import {
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type Flatten,
+  ensureArray,
+  getSearchParams,
+  request,
+  toAppType,
+} from '../utils.js';
+import type { FeatureCollection, Polygon } from 'geojson';
+import type { SnakeCase } from 'type-fest';
+
+type FieldName = 'id' | 'name' | 'description' | 'previewJson' | 'previewPath';
+
+const processGroupData = (group: GroupChoropleth): GroupChoropleth => ({
+  ...group,
+  ...group.nativeParentTranslation && { nativeParentTranslation: toAppType(group.nativeParentTranslation) },
+  ...group.nativeRelationTranslation && { nativeRelationTranslation: toAppType(group.nativeRelationTranslation) },
+  ...group.englishParentTranslation && { englishParentTranslation: toAppType(group.englishParentTranslation) },
+  ...group.englishRelationTranslation && { englishRelationTranslation: toAppType(group.englishRelationTranslation) },
+  ...group.parentTranslations && { parentTranslations: ensureArray(group.parentTranslations).map(toAppType) },
+  ...group.relationTranslations && { relationTranslations: ensureArray(group.relationTranslations).map(toAppType) },
+});
+
+const processPolygonData = (polygon: PolygonChoropleth): PolygonChoropleth => ({
+  ...polygon,
+  ...polygon.parentGroups && { parentGroups: ensureArray(polygon.parentGroups).map(toAppType).map(processGroupData) },
+  ...polygon.nativeTranslation && { nativeTranslation: toAppType(polygon.nativeTranslation) },
+  ...polygon.englishTranslation && { englishTranslation: toAppType(polygon.englishTranslation) },
+  ...polygon.translations && { translations: ensureArray(polygon.translations).map(toAppType) },
+});
+
+export type PartialVectorChoropleth = Pick<VectorChoropleth, FieldName>;
+
+export type VectorChoropleth = {
+  id: number;
+  name: string;
+  description: string;
+  previewPath: string | null;
+  previewJson: FeatureCollection | null;
+
+  vectorSetUrl: string;
+  sourceLayerName: string;
+
+  lngMin: number;
+  lngMax: number;
+  latMin: number;
+  latMax: number;
+
+  keys: string[];
+  properties: Array<Record<string, unknown>>;
+};
+
+export type ApiVectorChoropleth = {
+  data: {
+    id: number;
+    name: string;
+    description: string;
+    preview_path: string | null;
+    preview_json: FeatureCollection | null;
+
+    vector_set_url: string;
+    source_layer_name: string;
+
+    lng_min: number;
+    lng_max: number;
+    lat_min: number;
+    lat_max: number;
+
+    keys: string[];
+    properties: Array<Record<string, unknown>>;
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiVectorChoroplethData = Flatten<Exclude<ApiVectorChoropleth, ApiError>['data']>;
+
+export async function listVectorChoropleths(name: string): Promise<PartialVectorChoropleth[]> {
+  const pathname = `/v1/choropleths/vector`;
+  const query = getSearchParams({ search: { name } });
+  const path = `${pathname}?${query}`;
+
+  type ApiVectorChoroplethArray = {
+    data: Array<Pick<ApiVectorChoroplethData, SnakeCase<FieldName>>>;
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiVectorChoroplethArray, PartialVectorChoropleth>(path);
+}
+
+export async function getVectorChoropleth(choroplethId: number): Promise<VectorChoropleth> {
+  const path = `/v1/choropleths/vector/${choroplethId}`;
+
+  return request<ApiVectorChoropleth, VectorChoropleth>(path);
+}
+
+export type SearchBounds = {
+  min_lat: number;
+  min_lng: number;
+  max_lat: number;
+  max_lng: number;
+};
+
+export type PolygonChoropleth = {
+  sml: string;
+  id: number;
+  vectorSource: string;
+  sourceLayer: string;
+  featureId: number;
+  previewPath: string;
+  allowSingle: boolean;
+  properties: Record<string, unknown>;
+  boundingBox: Polygon;
+  restrictedOwnership: number[] | null;
+  linkId: number | null;
+  cloning: boolean;
+  nativeTranslation: {
+    polygonId: number;
+    name: string;
+  };
+  englishTranslation?: {
+    polygonId: number;
+    name: string;
+  };
+  translations?: Array<{
+    polygonId: number;
+    language: string;
+    name: string;
+  }>;
+  parentGroups: GroupChoropleth[];
+};
+
+export type ApiPolygonChoropleth = {
+  data: {
+    sml: string;
+    id: number;
+    vector_source: string;
+    source_layer: string;
+    feature_id: number;
+    preview_path: string;
+    allow_single: boolean;
+    properties: Record<string, unknown>;
+    bounding_box: Polygon;
+    restricted_ownership: number[] | null;
+    link_id: number | null;
+    cloning: boolean;
+    native_translation: {
+      polygon_id: number;
+      name: string;
+    };
+    english_translation?: {
+      polygon_id: number;
+      name: string;
+    };
+    translations?: Array<{
+      polygon_id: number;
+      language: string;
+      name: string;
+    }>;
+    parent_groups: ApiGroupChoroplethData[];
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiPolygonChoroplethData = Flatten<Exclude<ApiPolygonChoropleth, ApiError>['data']>;
+
+export async function listPolygonChoropleths(
+  name: string,
+  languages: string[],
+  searchBounds?: SearchBounds,
+  withParentGroups = false,
+): Promise<PolygonChoropleth[]> {
+  const pathname = `/v1/choropleth/polygons`;
+  const query = getSearchParams(
+    {
+      search: { name, allow_single: true },
+      with_parent_groups: withParentGroups,
+      languages,
+      ...searchBounds,
+    },
+  );
+  const path = `${pathname}?${query}`;
+
+  type ApiPolygonChoroplethArray = {
+    data: ApiPolygonChoroplethData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiPolygonChoroplethArray, PolygonChoropleth>(path).then(polygons => polygons.map(processPolygonData));
+}
+
+export type GroupChoropleth = {
+  id: number;
+  polygonId: number;
+  relationId: number;
+  childrenCount: number;
+  sml?: string;
+  previewPath: string;
+  uniqueProperties: string[];
+  boundingBox: Polygon;
+  partialProperties: string[];
+  restrictedOwnership: number[] | null;
+  linkId: number | null;
+  cloning: boolean;
+  laravelThroughKey?: number;
+  nativeParentTranslation: {
+    polygonId: number;
+    name: string;
+    laravelThroughKey: number;
+  };
+  nativeRelationTranslation: {
+    relationId: number;
+    name: string;
+    laravelThroughKey: number;
+  };
+  englishParentTranslation?: {
+    polygonId: number;
+    name: string;
+    laravelThroughKey: number;
+  };
+  englishRelationTranslation?: {
+    relationId: number;
+    name: string;
+    laravelThroughKey: number;
+  };
+  parentTranslations?: Array<{
+    polygonId: number;
+    name: string;
+    language: string;
+    laravelThroughKey: number;
+  }>;
+  relationTranslations?: Array<{
+    relationId: number;
+    name: string;
+    language: string;
+    laravelThroughKey: number;
+  }>;
+};
+
+export type ApiGroupChoropleth = {
+  data: {
+    id: number;
+    polygon_id: number;
+    relation_id: number;
+    children_count: number;
+    sml?: number;
+    preview_path: string;
+    unique_properties: string[];
+    bounding_box: Polygon;
+    partial_properties: string[];
+    restricted_ownership: number[] | null;
+    link_id: number | null;
+    cloning: boolean;
+    laravel_through_key?: number;
+    native_parent_translation: {
+      polygon_id: number;
+      name: string;
+      laravel_through_key: number;
+    };
+    native_relation_translation: {
+      relation_id: number;
+      name: string;
+      laravel_through_key: number;
+    };
+    english_parent_translation?: {
+      polygon_id: number;
+      name: string;
+      laravel_through_key: number;
+    };
+    english_relation_translation?: {
+      relation_id: number;
+      name: string;
+      laravel_through_key: number;
+    };
+    parent_translations?: Array<{
+      polygon_id: number;
+      name: string;
+      language: string;
+      laravel_through_key: number;
+    }>;
+    relation_translations?: Array<{
+      relation_id: number;
+      name: string;
+      language: string;
+      laravel_through_key: number;
+    }>;
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiGroupChoroplethData = Flatten<Exclude<ApiGroupChoropleth, ApiError>['data']>;
+
+export async function listGroupChoropleths(
+  name: string,
+  languages: string[],
+  searchBounds?: SearchBounds,
+): Promise<GroupChoropleth[]> {
+  const pathname = `/v1/choropleth/groups`;
+  const query = getSearchParams({ search: { name }, languages, ...searchBounds });
+  const path = `${pathname}?${query}`;
+
+  type ApiGroupChoroplethArray = {
+    data: ApiGroupChoroplethData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiGroupChoroplethArray, GroupChoropleth>(path).then(groups => groups.map(processGroupData));
+}
+
+export async function listChildrenGroupChoropleths(
+  groupId: number,
+  languages: string[],
+): Promise<PolygonChoropleth[]> {
+  const pathname = `/v1/choropleth/groups/${groupId}/children`;
+  const query = getSearchParams({ languages });
+  const path = `${pathname}?${query}`;
+
+  type ApiPolygonChoroplethArray = {
+    data: ApiPolygonChoroplethData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiPolygonChoroplethArray, PolygonChoropleth>(path).then(polygons => polygons.map(processPolygonData));
+}

package/src/api/color.ts

@@ -0,0 +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,
+};

package/src/api/dimension.ts

@@ -0,0 +1,54 @@
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type Unit =
+  | 'millimeter'
+  | 'centimeter'
+  | 'inch'
+  | 'pixel'
+  | 'pica'
+  | 'kilometer'
+  | 'mile'
+  | 'nauticalMile'
+  | 'foot'
+  | 'meter';
+
+export type Dimension = {
+  id: number;
+  dimensionSetId: number;
+  name: string;
+  width: number;
+  height: number;
+  dpi: number;
+  unit: Unit;
+};
+
+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]: Unit } = {
+  MM: 'millimeter',
+  CM: 'centimeter',
+  IN: 'inch',
+  PX: 'pixel',
+  PICA: 'pica',
+  KM: 'kilometer',
+  MI: 'mile',
+  NM: 'nauticalMile',
+  FT: 'foot',
+  M: 'meter',
+};
+
+export const dimensionRevivers: Revivers<ApiDimension, Dimension> = {
+  unit: (data: ApiDimensionData) => keyToUnit[data.unit],
+};

package/src/api/dimensionSet.ts

@@ -0,0 +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,
+};

package/src/api/feature.ts

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

package/src/api/font.ts

@@ -0,0 +1,30 @@
+import type { ApiCommonData, ApiError, ApiSuccess, Flatten, Revivers } from '../utils.js';
+
+export type Font = {
+  id: number;
+  fontFamilyId: number;
+  name: string;
+  label: string;
+};
+
+export type ApiFont = {
+  data: {
+    id: number;                 // The id of the font (sortable)
+    font_family_id: number;     // The id of the font family
+    name: string;               // The name of the font (searchable, sortable)
+    style: string;              // The font style (searchable, sortable)
+    stretch: string;            // The font stretch (searchable, sortable)
+    weight: number;             // The font weight (searchable, sortable)
+    label: string;              // The label of the font (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiFontData = Flatten<Exclude<ApiFont, ApiError>['data']>;
+
+export const fontRevivers: Revivers<ApiFont, Font> = {
+  style: undefined,
+  stretch: undefined,
+  weight: undefined,
+  order: undefined,
+};

package/src/api/fontFamily.ts

@@ -0,0 +1,43 @@
+import { type ApiFontData, type Font, fontRevivers } from './font.js';
+import {
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type Flatten,
+  type Revivers,
+  defaultListHeader,
+  getSearchParams,
+  request,
+} from '../utils.js';
+
+export type FontFamily = {
+  id: number;
+  name: string;
+};
+
+export type ApiFontFamily = {
+  data: {
+    id: number;                 // The id of the font family (sortable)
+    name: string;               // The name of the font family (searchable, sortable)
+    order?: number;             // TODO: not present in API specification!
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiFontFamilyData = Flatten<Exclude<ApiFontFamily, ApiError>['data']>;
+
+export const fontFamilyRevivers: Revivers<ApiFontFamily, FontFamily> = {
+  order: undefined,
+};
+
+export async function listFontFamilyFonts(fontFamilyId: number): Promise<Font[]> {
+  const pathname = `/v1/fonts/families/${fontFamilyId}/items`;
+  const query = getSearchParams({ sort: 'order' });
+  const path = `${pathname}?${query}`;
+  const options = { revivers: fontRevivers };
+
+  type ApiFontArray = {
+    data: ApiFontData[];
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiFontArray, Font>(path, null, defaultListHeader, options);
+}

package/src/api/highlight.ts

@@ -0,0 +1,74 @@
+import type { FeatureCollection } from 'geojson';
+import type { SnakeCase } from 'type-fest';
+import {
+  type ApiCommonData,
+  type ApiError,
+  type ApiSuccess,
+  type Flatten,
+  getSearchParams,
+  request,
+} from '../utils.js';
+
+type FieldName = 'id' | 'name' | 'description' | 'previewPath' | 'previewJson';
+
+export type PartialVectorHighlight = Pick<VectorHighlight, FieldName>;
+
+export type VectorHighlight = {
+  id: number;
+  name: string;
+  description: string;
+  previewPath: string | null;
+  previewJson: FeatureCollection | null;
+
+  vectorSetUrl: string;
+  sourceLayerName: string;
+
+  lngMin: number;
+  lngMax: number;
+  latMin: number;
+  latMax: number;
+
+  keys: string[];
+  properties: Record<string, unknown>;
+};
+
+export type ApiVectorHighlight = {
+  data: {
+    id: number;
+    name: string;
+    description: string;
+    preview_path: string | null;
+    preview_json: FeatureCollection | null;
+
+    vector_set_url: string;
+    source_layer_name: string;
+
+    lng_min: number;
+    lng_max: number;
+    lat_min: number;
+    lat_max: number;
+
+    keys: string[];
+    properties: Record<string, unknown>;
+  } & ApiCommonData;
+} & Omit<ApiSuccess, 'data'> | ApiError;
+
+export type ApiVectorHighlightData = Flatten<Exclude<ApiVectorHighlight, ApiError>['data']>;
+
+export async function listVectorHighlights(name: string): Promise<PartialVectorHighlight[]> {
+  const pathname = `/v1/highlights/vector`;
+  const query = getSearchParams({ search: { name } });
+  const path = `${pathname}?${query}`;
+
+  type ApiVectorHighlightArray = {
+    data: Array<Pick<ApiVectorHighlightData, SnakeCase<FieldName>>>;
+  } & Omit<ApiSuccess, 'data'> | ApiError;
+
+  return request<ApiVectorHighlightArray, PartialVectorHighlight>(path);
+}
+
+export async function getVectorHighlight(highlightId: number): Promise<VectorHighlight> {
+  const path = `/v1/highlights/vector/${highlightId}`;
+
+  return request<ApiVectorHighlight, VectorHighlight>(path);
+}