@reearth/core 0.0.2 → 0.0.4

package/dist/index.d.ts

@@ -148,6 +148,7 @@ export declare type Cesium3DTilesAppearance = {
     imageBasedLightIntensity?: number;
     showWireframe?: boolean;
     showBoundingVolume?: boolean;
+    cacheBytes?: number;
 };
 
 export declare type ClassificationType = "both" | "terrain" | "3dtiles";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reearth/core",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "Re:Earth contributors <community@reearth.io>",
   "license": "Apache-2.0",
   "description": "A library that abstracts a map engine as one common API.",
@@ -15,7 +15,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
-    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
+    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives",
     "preview": "vite preview",
     "test": "vitest",
     "storybook": "storybook dev -p 6007",
@@ -34,6 +34,7 @@
     "@seznam/compose-react-refs": "1.0.6",
     "@turf/invariant": "6.5.0",
     "@turf/turf": "6.5.0",
+    "@types/proj4": "2.5.5",
     "@ungap/event-target": "0.2.4",
     "@xstate/react": "3.2.1",
     "cesium-dnd": "1.1.0",
@@ -50,6 +51,7 @@
     "lodash-es": "4.17.21",
     "lru-cache": "8.0.4",
     "pbf": "3.2.1",
+    "proj4": "2.11.0",
     "protomaps": "1.23.1",
     "react-dnd": "16.0.1",
     "react-dnd-html5-backend": "16.0.1",

package/src/Map/utils.ts

@@ -20,8 +20,14 @@ export function mergeProperty(a: any, b: any) {
   return mergeWith(
     a2,
     b,
-    (s: any, v: any, _k: string | number | symbol, _obj: any, _src: any, stack: { size: number }) =>
-      stack.size > 0 || Array.isArray(v) ? v ?? s : undefined,
+    (
+      s: any,
+      v: any,
+      _k: string | number | symbol,
+      _obj: any,
+      _src: any,
+      stack: { size: number },
+    ) => (stack.size > 0 || Array.isArray(v) ? v ?? s : undefined),
   );
 }
 

package/src/engines/Cesium/hooks.ts

@@ -571,6 +571,12 @@ export default ({
       const viewer = cesium.current?.cesiumElement;
       if (!viewer || viewer.isDestroyed()) return;
 
+      if (!target || typeof target === "undefined" || !("id" in target && target.id)) {
+        viewer.selectedEntity = undefined;
+        onLayerSelect?.();
+        return;
+      }
+
       const entity =
         findEntity(viewer, undefined, selectedLayerId?.featureId) ||
         findEntity(viewer, selectedLayerId?.layerId);

package/src/engines/Cesium/type.d.ts

@@ -11,7 +11,6 @@ declare module "@cesium/engine" {
   // (...args: Parameter<Listener>[]).
   // This cannot be fixed by augmentation but by overloading.
   export interface Event<Listener extends (...args: any[]) => void = (...args: any[]) => void> {
-    // eslint-disable-next-line @typescript-eslint/method-signature-style
     raiseEvent(...arguments: Parameters<Listener>): void;
   }
 

package/src/engines/Cesium/utils/polygon.ts

@@ -21,8 +21,8 @@ export function convertGeometryToPositionsArray(
     geometry.type === "LineString"
       ? coordinatesToPositionsArray([geometry.coordinates])
       : geometry.type === "Polygon"
-      ? coordinatesToPositionsArray(geometry.coordinates)
-      : geometry.coordinates.flatMap(coordinates => coordinatesToPositionsArray(coordinates))
+        ? coordinatesToPositionsArray(geometry.coordinates)
+        : geometry.coordinates.flatMap(coordinates => coordinatesToPositionsArray(coordinates))
   ).filter(({ length }) => length > 0);
 }
 

package/src/mantle/atoms/compute.ts

@@ -178,8 +178,8 @@ export function computeAtom(cache?: typeof globalDataFeaturesCache) {
             ...("properties" in value
               ? { properties: value.properties }
               : l && "properties" in l
-              ? { properties: l.properties }
-              : {}),
+                ? { properties: l.properties }
+                : {}),
           }
         : undefined,
     );

package/src/mantle/data/gpx.ts

@@ -24,7 +24,7 @@ const handler = (xmlDataStr: string) => {
 const parseGPX = (gpxSource: string) => {
   const parseMethod = (gpxSource: string): Document | null => {
     // Verify that we are in a browser
-    if (typeof document == undefined) return null;
+    if (typeof document === "undefined") return null;
 
     const domParser = new window.DOMParser();
     return domParser.parseFromString(gpxSource, "text/xml");

package/src/mantle/data/shapefile/index.ts

@@ -0,0 +1,51 @@
+import type { GeometryObject, Feature as GeoJSONFeature, FeatureCollection } from "geojson";
+
+import type { Data, DataRange, Feature } from "../../types";
+import { processGeoJSON } from "../geojson";
+import { f, FetchOptions, generateRandomString } from "../utils";
+
+import { parseZip } from "./parseZip";
+
+export async function combine(
+  shp: GeoJSONFeature<GeometryObject>[],
+  dbf?: any[],
+): Promise<FeatureCollection> {
+  const out: FeatureCollection = {
+    type: "FeatureCollection",
+    features: [],
+  };
+  const len = shp.length;
+  dbf = dbf || [];
+  for (let i = 0; i < len; i++) {
+    out.features.push({
+      type: "Feature",
+      geometry: shp[i].geometry,
+      id: generateRandomString(12),
+      properties: dbf[i] || {},
+    });
+  }
+  return out;
+}
+
+export async function fetchShapefile(
+  data: Data,
+  range?: DataRange,
+  options?: FetchOptions,
+): Promise<Feature[] | void> {
+  const arrayBuffer = data.url ? await (await f(data.url, options)).arrayBuffer() : data.value;
+
+  if (!arrayBuffer) {
+    console.error("No data provided");
+  }
+
+  const geojson = await parseZip(arrayBuffer);
+  if (Array.isArray(geojson)) {
+    const combinedFeatureCollection: FeatureCollection = {
+      type: "FeatureCollection",
+      features: geojson.flatMap(layer => (layer as FeatureCollection).features),
+    };
+    return processGeoJSON(combinedFeatureCollection, range);
+  } else {
+    return processGeoJSON(geojson as FeatureCollection, range);
+  }
+}

package/src/mantle/data/shapefile/parseDbf.ts

@@ -0,0 +1,85 @@
+export function parseDbf(dbf: ArrayBuffer, cpg?: string): Record<string, any>[] {
+  const header = parseHeader(dbf);
+  const records = parseRecords(dbf, header, cpg);
+  return records;
+}
+
+export function parseHeader(dbf: ArrayBuffer): {
+  version: number;
+  dateUpdated: Date;
+  recordCount: number;
+  recordSize: number;
+  fields: {
+    name: string;
+    type: string;
+    size: number;
+    decimals: number;
+  }[];
+} {
+  const view = new DataView(dbf);
+  const version = view.getUint8(0);
+  const dateUpdated = new Date(1900 + view.getUint8(1), view.getUint8(2) - 1, view.getUint8(3));
+  const recordCount = view.getInt32(4, true);
+  const headerSize = view.getInt16(8, true);
+  const recordSize = view.getInt16(10, true);
+  const fields = parseFields(new DataView(dbf, 32, headerSize - 32));
+  return { version, dateUpdated, recordCount, recordSize, fields };
+}
+
+function parseFields(fieldData: DataView): {
+  name: string;
+  type: string;
+  size: number;
+  decimals: number;
+}[] {
+  const fields = [];
+  let offset = 0;
+  while (offset < fieldData.byteLength && fieldData.getUint8(offset) !== 0x0d) {
+    const name = new TextDecoder()
+      .decode(new Uint8Array(fieldData.buffer, fieldData.byteOffset + offset, 11))
+      .replace(/\0.*/g, "");
+    const type = String.fromCharCode(fieldData.getUint8(offset + 11));
+    const size = fieldData.getUint8(offset + 16);
+    const decimals = fieldData.getUint8(offset + 17);
+    fields.push({ name, type, size, decimals });
+    offset += 32;
+  }
+  return fields;
+}
+
+function parseRecords(
+  dbf: ArrayBuffer,
+  header: ReturnType<typeof parseHeader>,
+  cpg?: string,
+): Record<string, any>[] {
+  const records = [];
+  const decoder = cpg ? new TextDecoder(cpg) : new TextDecoder();
+  const fields = header.fields;
+  for (let i = 0; i < header.recordCount; i++) {
+    const record: Record<string, any> = {};
+    const offset = header.recordSize * i + 1;
+    for (const field of fields) {
+      const value = new TextDecoder().decode(new Uint8Array(dbf, offset, field.size)).trim();
+      switch (field.type) {
+        case "N":
+        case "F":
+          record[field.name] = parseFloat(value);
+          break;
+        case "D":
+          record[field.name] = new Date(
+            parseInt(value.slice(0, 4), 10),
+            parseInt(value.slice(4, 6), 10) - 1,
+            parseInt(value.slice(6, 8), 10),
+          );
+          break;
+        case "L":
+          record[field.name] = value.toLowerCase() === "y" || value.toLowerCase() === "t";
+          break;
+        default:
+          record[field.name] = decoder.decode(new Uint8Array(dbf, offset, field.size)).trim();
+      }
+    }
+    records.push(record);
+  }
+  return records;
+}