@reearth/core 0.0.1

package/src/mantle/compat/backward.test.ts

@@ -0,0 +1,368 @@
+import { expect, test } from "vitest";
+
+import { Infobox } from "../../reearthTypes";
+
+import { convertLayer, getCompat } from "./backward";
+import type { Tag } from "./types";
+
+const infobox: Infobox = { blocks: [], property: { default: { position: { value: "left" } } } };
+const tags: Tag[] = [{ id: "x", label: "x" }];
+
+test("group", () => {
+  expect(
+    convertLayer({
+      id: "xxx",
+      type: "group",
+      children: [
+        {
+          id: "yyy",
+          type: "group",
+          children: [],
+        },
+      ],
+      visible: true,
+      compat: {
+        property: { a: 1 },
+        propertyId: "p",
+        extensionId: "hoge",
+      },
+      title: "title",
+      creator: "creator",
+      infobox,
+      tags,
+    }),
+  ).toEqual({
+    id: "xxx",
+    children: [
+      {
+        id: "yyy",
+        children: [],
+      },
+    ],
+    title: "title",
+    isVisible: true,
+    creator: "creator",
+    infobox,
+    tags,
+    pluginId: "reearth",
+    extensionId: "hoge",
+    property: { a: 1 },
+    propertyId: "p",
+  });
+});
+
+test("item", () => {
+  expect(
+    convertLayer({
+      id: "xxx",
+      type: "simple",
+      visible: true,
+      compat: {
+        property: { a: 1 },
+        propertyId: "p",
+        extensionId: "hoge",
+      },
+      title: "title",
+      creator: "creator",
+      infobox,
+      tags,
+    }),
+  ).toEqual({
+    id: "xxx",
+    isVisible: true,
+    title: "title",
+    creator: "creator",
+    infobox,
+    tags,
+    pluginId: "reearth",
+    extensionId: "hoge",
+    property: { a: 1 },
+    propertyId: "p",
+  });
+});
+
+test("getCompat", () => {
+  expect(getCompat(undefined)).toBeUndefined();
+  expect(getCompat({ type: "aaa" } as any)).toBeUndefined();
+});
+
+test("marker", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [1, 2, 3],
+          },
+        },
+      },
+      marker: {
+        pointColor: "red",
+      },
+      compat: {
+        propertyId: "p",
+      },
+    }),
+  ).toEqual({
+    extensionId: "marker",
+    propertyId: "p",
+    property: {
+      default: {
+        location: { lat: 2, lng: 1 },
+        height: 3,
+        pointColor: "red",
+      },
+    },
+  });
+});
+
+test("polyline", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: {
+          type: "Feature",
+          geometry: {
+            type: "LineString",
+            coordinates: [
+              [1, 2, 3],
+              [2, 3, 4],
+            ],
+          },
+        },
+      },
+      polyline: {
+        strokeColor: "red",
+      },
+      compat: {
+        propertyId: "p",
+      },
+    } as any),
+  ).toEqual({
+    extensionId: "polyline",
+    propertyId: "p",
+    property: {
+      default: {
+        coordinates: [
+          { lat: 2, lng: 1, height: 3 },
+          { lat: 3, lng: 2, height: 4 },
+        ],
+        strokeColor: "red",
+      },
+    },
+  });
+});
+
+test("polygon", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: {
+          type: "Feature",
+          geometry: {
+            type: "Polygon",
+            coordinates: [
+              [
+                [1, 2, 3],
+                [2, 3, 4],
+              ],
+            ],
+          },
+        },
+      },
+      polygon: {
+        fillColor: "red",
+      },
+      compat: {
+        propertyId: "p",
+      },
+    } as any),
+  ).toEqual({
+    extensionId: "polygon",
+    propertyId: "p",
+    property: {
+      default: {
+        polygon: [
+          [
+            { lat: 2, lng: 1, height: 3 },
+            { lat: 3, lng: 2, height: 4 },
+          ],
+        ],
+        fillColor: "red",
+      },
+    },
+  });
+});
+
+test("photooverlay", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [1, 2, 3],
+          },
+        },
+      },
+      photooverlay: {
+        imageSize: 1,
+      },
+      compat: {
+        propertyId: "p",
+      },
+    }),
+  ).toEqual({
+    extensionId: "photooverlay",
+    propertyId: "p",
+    property: {
+      default: {
+        location: { lat: 2, lng: 1 },
+        height: 3,
+        imageSize: 1,
+      },
+    },
+  });
+});
+
+test("ellipsoid", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [1, 2, 3],
+          },
+        },
+      },
+      ellipsoid: {
+        radii: 100,
+      },
+      compat: {
+        propertyId: "p",
+      },
+    } as any),
+  ).toEqual({
+    extensionId: "ellipsoid",
+    propertyId: "p",
+    property: {
+      default: {
+        position: { lat: 2, lng: 1 },
+        height: 3,
+        radii: 100,
+      },
+    },
+  });
+});
+
+test("model", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: {
+          type: "Feature",
+          geometry: {
+            type: "Point",
+            coordinates: [1, 2, 3],
+          },
+        },
+      },
+      model: {
+        model: "xxx",
+        color: "red",
+      },
+      compat: {
+        propertyId: "p",
+      },
+    } as any),
+  ).toEqual({
+    extensionId: "model",
+    propertyId: "p",
+    property: {
+      default: {
+        location: { lat: 2, lng: 1 },
+        height: 3,
+        model: "xxx",
+      },
+      appearance: {
+        color: "red",
+      },
+    },
+  });
+});
+
+test("3dtiles", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      data: {
+        type: "3dtiles",
+        url: "xxx",
+      },
+      "3dtiles": {
+        aaaa: 1,
+      },
+      compat: {
+        propertyId: "p",
+      },
+    } as any),
+  ).toEqual({
+    extensionId: "tileset",
+    propertyId: "p",
+    property: {
+      default: {
+        tileset: "xxx",
+        aaaa: 1,
+      },
+    },
+  });
+});
+
+test("resource", () => {
+  expect(
+    getCompat({
+      id: "xxx",
+      type: "simple",
+      resource: {
+        url: "xxx",
+        aaaa: 1,
+      },
+      compat: {
+        propertyId: "p",
+      },
+    } as any),
+  ).toEqual({
+    extensionId: "resource",
+    propertyId: "p",
+    property: {
+      default: {
+        url: "xxx",
+        aaaa: 1,
+      },
+    },
+  });
+});

package/src/mantle/compat/backward.ts

@@ -0,0 +1,189 @@
+import type { GeoJSON } from "geojson";
+import { omit, omitBy, pick } from "lodash-es";
+
+import type { Layer, LayerCompat } from "../types";
+import { getCoord, getCoords, getGeom } from "../utils";
+
+import type { LegacyLayer } from ".";
+
+export function convertLayer(l: Layer): LegacyLayer | undefined {
+  return convertLayerGroup(l) ?? convertLayerItem(l);
+}
+
+function convertLayerCommon(l: Layer): any {
+  return omitBy(
+    {
+      id: l.id,
+      isVisible: l.visible,
+      title: l.title,
+      creator: l.creator,
+      infobox: l.infobox,
+      tags: l.tags,
+      property: l.compat?.property,
+      propertyId: l.compat?.propertyId,
+      pluginId: l.compat?.extensionId ? "reearth" : undefined,
+      extensionId: l.compat?.extensionId,
+    },
+    v => typeof v === "undefined" || v === null,
+  );
+}
+
+function convertLayerGroup(l: Layer): LegacyLayer | undefined {
+  if (l.type !== "group") return;
+
+  return {
+    ...convertLayerCommon(l),
+    children: l.children?.map(convertLayer).filter((l): l is LegacyLayer => !!l) ?? [],
+  };
+}
+
+function convertLayerItem(l: Layer): LegacyLayer | undefined {
+  if (l.type !== "simple") return;
+
+  return convertLayerCommon(l);
+}
+
+export function getCompat(l: Layer | undefined): LayerCompat | undefined {
+  if (!l || typeof l !== "object" || l.type !== "simple") return;
+
+  const data: GeoJSON | undefined = l.data?.type === "geojson" ? l.data.value : undefined;
+
+  let property: any;
+  let extensionId: string | undefined;
+
+  if ("marker" in l) {
+    const coord = getCoord(data);
+    extensionId = "marker";
+    property = {
+      default: {
+        ...l.marker,
+        ...(coord && coord.length >= 2
+          ? {
+              location: { lng: coord[0], lat: coord[1] },
+              height: coord[2],
+            }
+          : {}),
+      },
+    };
+  } else if ("polyline" in l) {
+    const coords = getCoords(data);
+    extensionId = "polyline";
+    property = {
+      default: {
+        ...(l as any).polyline,
+        ...(coords
+          ? {
+              coordinates: coords.map(c => ({ lng: c[0], lat: c[1], height: c[2] })),
+            }
+          : {}),
+      },
+    };
+  } else if ("polygon" in l) {
+    // rect is also included in polygon
+    const geo = getGeom(data);
+    extensionId = "polygon";
+    property = {
+      default: {
+        ...(l as any).polygon,
+        ...(geo?.type === "Polygon"
+          ? {
+              polygon: geo.coordinates.map(coords =>
+                coords.map(c => ({ lng: c[0], lat: c[1], height: c[2] })),
+              ),
+            }
+          : {}),
+      },
+    };
+  } else if ("photooverlay" in l) {
+    const coord = getCoord(data);
+    extensionId = "photooverlay";
+    property = {
+      default: {
+        ...(l as any).photooverlay,
+        ...(coord && coord.length >= 2
+          ? {
+              location: { lng: coord[0], lat: coord[1] },
+              height: coord[2],
+            }
+          : {}),
+      },
+    };
+  } else if ("ellipsoid" in l) {
+    const coord = getCoord(data);
+    extensionId = "ellipsoid";
+    property = {
+      default: {
+        ...(l as any).ellipsoid,
+        ...(coord && coord.length >= 2
+          ? {
+              position: { lng: coord[0], lat: coord[1] },
+              height: coord[2],
+            }
+          : {}),
+      },
+    };
+  } else if ("model" in l) {
+    const appearanceKeys = [
+      "shadows",
+      "colorBlend",
+      "color",
+      "colorBlendAmount",
+      "lightColor",
+      "silhouette",
+      "silhouetteColor",
+      "silhouetteSize",
+    ];
+    const m = omit((l as any).model, ...appearanceKeys);
+    const a = omitBy(
+      pick((l as any).model, ...appearanceKeys),
+      v => typeof v === "undefined" || v === null,
+    );
+    const coord = getCoord(data);
+    extensionId = "model";
+    property = {
+      default: {
+        ...m,
+        ...(coord && coord.length >= 2
+          ? {
+              location: { lng: coord[0], lat: coord[1] },
+              height: coord[2],
+            }
+          : {}),
+      },
+      ...(Object.keys(a).length
+        ? {
+            appearance: a,
+          }
+        : {}),
+    };
+  } else if ("3dtiles" in l) {
+    extensionId = "tileset";
+    property = {
+      default: {
+        ...(l as any)["3dtiles"],
+        ...((l as any).data?.type === "3dtiles" && (l as any).data.url
+          ? {
+              tileset: (l as any).data.url,
+            }
+          : {}),
+      },
+    };
+  } else if ("resource" in l) {
+    extensionId = "resource";
+    property = {
+      default: {
+        ...(l as any).resource,
+      },
+    };
+  }
+
+  return {
+    extensionId,
+    property,
+    ...(l.compat?.propertyId
+      ? {
+          propertyId: l.compat?.propertyId,
+        }
+      : {}),
+  };
+}