@reearth/core 0.0.1

package/src/mantle/data/geojson.ts

@@ -0,0 +1,72 @@
+import type { GeoJSON } from "geojson";
+
+import type { Data, DataRange, Feature } from "../types";
+
+import { f, FetchOptions, generateRandomString } from "./utils";
+
+export async function fetchGeoJSON(
+  data: Data,
+  range?: DataRange,
+  options?: FetchOptions,
+): Promise<Feature[] | void> {
+  const d = data.url ? await (await f(data.url, options)).json() : data.value;
+  return processGeoJSON(d, range);
+}
+
+export function processGeoJSON(geojson: GeoJSON, range?: DataRange): Feature[] {
+  if (geojson.type === "FeatureCollection") {
+    return geojson.features.flatMap(f => processGeoJSON(f, range));
+  }
+
+  if (geojson.type === "Feature") {
+    const geo = geojson.geometry;
+    if (geo.type === "MultiPoint") {
+      return geo.coordinates.flatMap(coord => {
+        return processGeoJSON({
+          ...geojson,
+          geometry: {
+            type: "Point",
+            coordinates: coord,
+          },
+        });
+      });
+    }
+    if (geo.type === "MultiLineString") {
+      return geo.coordinates.flatMap(coord => {
+        return processGeoJSON({
+          ...geojson,
+          geometry: {
+            type: "LineString",
+            coordinates: coord,
+          },
+        });
+      });
+    }
+    if (geo.type === "MultiPolygon") {
+      return geo.coordinates.flatMap(coord => {
+        return processGeoJSON({
+          ...geojson,
+          geometry: {
+            type: "Polygon",
+            coordinates: coord,
+          },
+        });
+      });
+    }
+
+    return [
+      {
+        type: "feature",
+        id: generateRandomString(12),
+        geometry:
+          geo.type === "Point" || geo.type === "LineString" || geo.type === "Polygon"
+            ? geo
+            : undefined,
+        properties: geojson.properties,
+        range,
+      },
+    ];
+  }
+
+  return [];
+}

package/src/mantle/data/georss.ts

@@ -0,0 +1,172 @@
+import { XMLParser, X2jOptionsOptional } from "fast-xml-parser";
+
+import type { Data, DataRange, Feature, Geometry } from "../types";
+
+import { getGeometryOfItem } from "./gml";
+import type { Shape } from "./gml";
+import { f, convertToCoordinates, FetchOptions } from "./utils";
+
+export async function fetchGeoRSS(
+  data: Data,
+  _range?: DataRange,
+  options?: FetchOptions,
+): Promise<Feature[] | void> {
+  const xmlDataStr = data.url ? await (await f(data.url, options)).text() : data.value;
+  return handler(xmlDataStr);
+}
+
+function handler(xmlDataStr: string) {
+  const cleanXml = xmlDataStr.replace(/([a-zA-Z]+:)/g, "");
+  const geoRSSData = parseBuffer(cleanXml);
+  if ("rss" in geoRSSData) {
+    return parseGeoRSS2(geoRSSData as GeoRSS2);
+  } else if ("feed" in geoRSSData) {
+    return parseGeoRSSAtom(geoRSSData as GeoRSSAtom);
+  } else {
+    throw new Error("GeoRSS format not supported");
+  }
+}
+
+function parseBuffer(xmlDataStr: string) {
+  const options: X2jOptionsOptional = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+  };
+  const parser = new XMLParser(options);
+  return parser.parse(xmlDataStr);
+}
+
+function parseGeoRSSAtom(geoRSS: GeoRSSAtom): Feature[] {
+  const { entry } = geoRSS.feed;
+  return parserEntries(entry);
+}
+
+function parseGeoRSS2(geoRSS: GeoRSS2) {
+  const item = geoRSS.rss.channel.item;
+  return parserEntries(item);
+}
+
+function parserEntries(entry: Entry[]) {
+  const result: Feature[] = [];
+  for (const item of entry) {
+    let geometry: Geometry = {
+      type: "Point",
+      coordinates: [1, 1],
+    };
+
+    if (item.where) {
+      const shape = item.where;
+      geometry = getGeometryOfItem(shape);
+    } else if (item.point) {
+      geometry = {
+        type: "Point",
+        coordinates: convertToCoordinates(item.point),
+      };
+    } else if (item.line) {
+      geometry = {
+        type: "LineString",
+        coordinates: item.line.split(" ").map(point => convertToCoordinates(point)),
+      };
+    } else if (item.polygon || item.box) {
+      let coordinates = [0];
+      if (item.polygon) {
+        coordinates = convertToCoordinates(item.polygon);
+      } else if (item.box) {
+        coordinates = convertToCoordinates(item.box);
+      }
+      geometry = {
+        type: "Polygon",
+        coordinates: [
+          [
+            [coordinates[1], coordinates[0]],
+            [coordinates[3], coordinates[2]],
+            [coordinates[5], coordinates[4]],
+            [coordinates[1], coordinates[0]],
+          ],
+        ],
+      };
+    }
+
+    const feature: Feature = {
+      type: "feature",
+      id: item.id,
+      properties: {
+        title: item.title,
+        link: item.link.href,
+        id: item.id,
+        updated: item.updated,
+        content: item.content,
+      },
+      geometry,
+    };
+
+    result.push(feature);
+  }
+
+  return result;
+}
+
+type Link = {
+  href: string;
+};
+
+type Author = {
+  name: string;
+  email: string;
+};
+
+type Entry = {
+  title: string;
+  link: Link;
+  id: string;
+  updated: string;
+  content: string;
+  where?: Shape;
+  point?: string;
+  line?: string;
+  polygon?: string;
+  box?: string;
+  Point?: {
+    lat: number;
+    long: number;
+  };
+  lat_long?: string;
+};
+
+type Feed = {
+  title: string;
+  subtitle: string;
+  link: Link[];
+  updated: string;
+  author: Author;
+  entry: Entry[];
+  xmlns: string;
+  georss: string;
+  gml: string;
+  geo: string;
+};
+
+type GeoRSSAtom = {
+  feed: Feed;
+};
+
+type GeoRSS2 = {
+  rss: RSS;
+};
+
+type RSS = {
+  channel: Channel;
+  xmlns: string;
+  georss: string;
+  gml: string;
+  geo: string;
+};
+
+type Channel = {
+  title: string;
+  subtitle: string;
+  link: Link[];
+  updated: string;
+  author: Author;
+  item: Entry[];
+};

package/src/mantle/data/gml.ts

@@ -0,0 +1,244 @@
+import { XMLParser, X2jOptionsOptional } from "fast-xml-parser";
+
+import type { Data, DataRange, Feature, Geometry } from "../types";
+
+import { f, convertToCoordinates, FetchOptions } from "./utils";
+
+export async function fetchGMLData(
+  data: Data,
+  _range?: DataRange,
+  options?: FetchOptions,
+): Promise<Feature[] | void> {
+  const xmlDataStr = data.url ? await (await f(data.url, options)).text() : data.value;
+  return handler(xmlDataStr);
+}
+
+function handler(xmlDataStr: string) {
+  const cleanXml = xmlDataStr.replace(/([a-zA-Z]+:)/g, "");
+
+  const gmlData = parseBuffer(cleanXml);
+  return transform(gmlData);
+}
+
+function parseBuffer(xmlDataStr: string) {
+  const options: X2jOptionsOptional = {
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+  };
+  const parser = new XMLParser(options);
+  return parser.parse(xmlDataStr) as GMLFeatureCollection;
+}
+
+function transform(gmlFeatureCollection: GMLFeatureCollection): Feature[] {
+  const stations = gmlFeatureCollection.FeatureCollection.featureMember;
+  const result: Feature[] = [];
+
+  if (stations) {
+    for (const station of stations) {
+      const {
+        Shape: shape,
+        name: name,
+        WMO_ID: WMO_ID,
+        alternative_ID: alternative_ID,
+        elevation: elevation,
+        hash: hash,
+        fid: fid,
+      } = station["stations_mix-obs"];
+      const properties = {
+        name,
+        WMO_ID,
+        alternative_ID,
+        elevation,
+        hash,
+        fid,
+      };
+
+      const geometry = getGeometryOfItem(shape);
+
+      const feature: Feature = {
+        type: "feature",
+        id: fid,
+        properties,
+        geometry,
+      };
+      result.push(feature);
+    }
+  }
+  return result;
+}
+
+export function getGeometryOfItem(shape: Shape): Geometry {
+  let geometry: Geometry = {
+    type: "Point",
+    coordinates: [1],
+  };
+
+  if ("Point" in shape) {
+    const coordinates = getCoordinatesFromPoint(shape.Point);
+    if (coordinates) {
+      geometry = {
+        type: "Point",
+        coordinates: convertToCoordinates(coordinates),
+      };
+    }
+  } else if ("MultiPoint" in shape) {
+    geometry = {
+      type: "MultiPoint",
+      coordinates: shape.MultiPoint.pointMember.map(point => {
+        const coordinates = getCoordinatesFromPoint(point.Point);
+        return convertToCoordinates(coordinates);
+      }),
+    };
+  } else if ("LineString" in shape) {
+    const lineString = shape.LineString;
+    geometry = {
+      type: "LineString",
+      coordinates: lineString.posList.split(" ").map(point => convertToCoordinates(point)),
+    };
+  } else if ("MultiLineString" in shape) {
+    geometry = {
+      type: "MultiLineString",
+      coordinates: shape.MultiLineString.lineStringMember.map(lineString => {
+        const line = lineString.LineString;
+        return line.posList.split(" ").map(point => convertToCoordinates(point));
+      }),
+    };
+  } else if ("MultiPolygon" in shape) {
+    let interior: number[][][] = [[[1]]];
+    geometry = {
+      type: "MultiPolygon",
+      coordinates: shape.MultiPolygon.polygonMember.map(polygon => {
+        const exterior = polygon.Polygon.exterior.LinearRing.posList
+          .split(" ")
+          .map(point => convertToCoordinates(point));
+        if (polygon.Polygon.interior) {
+          interior = polygon.Polygon.interior.map(interiorRing => {
+            const ring = interiorRing.LinearRing;
+            return ring.posList.split(" ").map(point => convertToCoordinates(point));
+          });
+        }
+        return [exterior, ...interior];
+      }),
+    };
+  } else if ("Polygon" in shape) {
+    const polygon = shape.Polygon;
+    const exterior = polygon.exterior.LinearRing.posList
+      .split(" ")
+      .map(point => convertToCoordinates(point));
+    let interior: number[][][] = [[[]]];
+    if (polygon.interior) {
+      interior = polygon.interior.map(interiorRing => {
+        const ring = interiorRing.LinearRing;
+        return ring.posList.split(" ").map(point => convertToCoordinates(point));
+      });
+    }
+    geometry = {
+      type: "Polygon",
+      coordinates: [exterior, ...interior],
+    };
+  } else {
+    throw new Error("unsupported shape");
+  }
+
+  return geometry;
+}
+
+function getCoordinatesFromPoint(point: Coordinates) {
+  if (point.coordinates) {
+    return point.coordinates;
+  } else if (point.pos) {
+    return point.pos;
+  }
+  throw new Error("something went wrong");
+}
+
+type Xml = {
+  version: string;
+  encoding: string;
+};
+
+type Coordinates = {
+  pos?: string;
+  coordinates?: string;
+  srsName?: string;
+};
+
+type Point = {
+  Point: Coordinates;
+};
+
+type MultiPoint = {
+  MultiPoint: {
+    pointMember: Point[];
+  };
+};
+
+type LineString = {
+  LineString: Coordinates & {
+    posList: string;
+  };
+};
+
+type MultiLineString = {
+  MultiLineString: {
+    lineStringMember: LineString[];
+  };
+};
+
+type Polygon = {
+  Polygon: {
+    exterior: {
+      LinearRing: Coordinates & {
+        posList: string;
+      };
+    };
+    interior?: {
+      LinearRing: Coordinates & {
+        posList: string;
+      };
+    }[];
+  };
+};
+
+type MultiPolygon = {
+  MultiPolygon: {
+    polygonMember: Polygon[];
+  };
+};
+
+export type Shape = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;
+
+type StationsMixObs = {
+  "stations_mix-obs": {
+    Shape: Shape;
+    name?: string;
+    WMO_ID?: number;
+    alternative_ID?: string;
+    elevation?: string;
+    hash?: number;
+    fid: string;
+  };
+};
+
+type Box = {
+  Box: Coordinates;
+};
+
+type BoundedBy = {
+  boundedBy: Box;
+};
+
+type FeatureCollection1 = {
+  boundedBy: BoundedBy;
+  featureMember?: StationsMixObs[];
+  "xmlns:mm": string;
+  "xmlns:gml": string;
+  "xmlns:wfs": string;
+  "xmlns:xsi": string;
+  "xsi:schemaLocation": string;
+};
+
+type GMLFeatureCollection = {
+  "?xml": Xml;
+  FeatureCollection: FeatureCollection1;
+};

package/src/mantle/data/gpx.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test, vi } from "vitest";
+
+import { Data } from "../types";
+
+import { fetchGPXfile } from "./gpx";
+import * as Utils from "./utils";
+
+describe("with header", async () => {
+  const mockGPXData = `<?xml version="1.0" encoding="UTF-8"?>
+  <gpx xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.topografix.com/GPX/1/0" xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd" creator="Yamareco Android 6.1.3 - www.yamareco.com">
+  <trk><name>track</name><number>1</number><trkseg>
+  <trkpt lat="37.7237236" lon="140.2551358"><ele>1578</ele><time>2022-09-24T23:05:14Z</time></trkpt>
+  <trkpt lat="37.7237021" lon="140.255021"><ele>1578</ele><time>2022-09-24T23:06:23Z</time></trkpt>
+  <trkpt lat="37.7234781" lon="140.254876"><ele>1578</ele><time>2022-09-24T23:06:37Z</time></trkpt>
+  <trkpt lat="37.7233925" lon="140.2548113"><ele>1578</ele><time>2022-09-24T23:07:22Z</time></trkpt>
+  <trkpt lat="37.7231886" lon="140.2548331"><ele>1577</ele><time>2022-09-24T23:07:42Z</time></trkpt>
+  </trkseg>
+  </trk>
+  <trk><name>track</name><number>2</number><trkseg>
+  <trkpt lat="37.7237236" lon="140.2551358"><ele>1578</ele><time>2022-09-24T23:05:14Z</time></trkpt>
+  <trkpt lat="37.7237021" lon="140.255021"><ele>1578</ele><time>2022-09-24T23:06:23Z</time></trkpt>
+  <trkpt lat="37.7234781" lon="140.254876"><ele>1578</ele><time>2022-09-24T23:06:37Z</time></trkpt>
+  <trkpt lat="37.7233925" lon="140.2548113"><ele>1578</ele><time>2022-09-24T23:07:22Z</time></trkpt>
+  <trkpt lat="37.7231886" lon="140.2548331"><ele>1577</ele><time>2022-09-24T23:07:42Z</time></trkpt>
+  </trkseg>
+  </trk>
+  </gpx>`;
+
+  test("returns a list of GeoJSON LineString features", async () => {
+    const fetchDataMock = vi.spyOn(Utils, "f");
+    fetchDataMock.mockImplementation(async () => {
+      return {
+        text: async () => mockGPXData,
+      } as Response;
+    });
+    const data: Data = {
+      type: "gpx",
+      url: "https://example.com/tracks.gpx",
+    };
+    const features = await fetchGPXfile(data);
+    expect(Array.isArray(features)).toBe(true);
+    features?.forEach(f => {
+      expect(f.type).toBe("feature");
+      expect(f?.geometry?.type).toBe("LineString");
+      expect(Array.isArray(f?.geometry?.coordinates)).toBe(true);
+      expect(f?.geometry?.coordinates.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  test("parses GPX files with one or multiple tracks", async () => {
+    const fetchDataMock = vi.spyOn(Utils, "f");
+    fetchDataMock.mockImplementation(async () => {
+      return {
+        text: async () => mockGPXData,
+      } as Response;
+    });
+    const data: Data = {
+      type: "gpx",
+      url: "https://example.com/tracks.gpx",
+    };
+    const features = await fetchGPXfile(data);
+    expect(Array.isArray(features)).toBe(true);
+    expect(features?.length).toBeGreaterThan(0);
+  });
+});