@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/api/{import-export → impl/import-export}/geojson-export.js

@@ -17,8 +17,10 @@
  * does not handle the antimeridian draws the other way round the world. The orientation of a
  * ring is judged before the longitudes are brought back, on the continuous ring.
  */
-import { normalizeMultiPolygonOrientation, normalizePolygonOrientation, } from '../../geometry/index.js';
-import { GEOJSON_COORDINATE_DECIMALS, GEOJSON_PREFIX, LIBRARY_PROPERTIES } from './constants.js';
+import { normalizeMultiPolygonOrientation, normalizePolygonOrientation, } from '../../../geometry/simplify.js';
+import { DRAW_PROPERTY_PREFIX, getDrawProperty } from '../../../shared/properties.js';
+import { listShownFeatures } from '../../../store/local-visibility.js';
+import { GEOJSON_COORDINATE_DECIMALS } from './constants.js';
 import { setOwnProperty } from './own-property.js';
 const COORDINATE_SCALE = 10 ** GEOJSON_COORDINATE_DECIMALS;
 /** Rounds one coordinate value to the exported number of decimal places */
@@ -66,124 +68,89 @@ function wrapRings(rings) {
 function exportPolygon(rings) {
     return wrapRings(normalizePolygonOrientation(rings.map(roundLine)));
 }
-/** Whether it is a single coordinate ([lng, lat]) */
-function isCoordinatePair(value) {
-    return (Array.isArray(value) &&
-        value.length === 2 &&
-        typeof value[0] === 'number' &&
-        typeof value[1] === 'number');
-}
-/** Whether it is a sequence of points ([[lng, lat], …], two or more points) */
-function isCoordinatePairArray(value) {
-    return Array.isArray(value) && value.length >= 2 && value.every(isCoordinatePair);
+/**
+ * The geometry as it is exported: the positions rounded, the rings oriented by the right-hand
+ * rule and the longitudes brought into [-180, 180] (null for a GeometryCollection, which no
+ * feature holds)
+ */
+function exportGeometry(geometry) {
+    switch (geometry.type) {
+        case 'Point':
+            return { type: 'Point', coordinates: exportPosition(geometry.coordinates) };
+        case 'LineString':
+            return { type: 'LineString', coordinates: exportLine(geometry.coordinates) };
+        case 'Polygon':
+            return { type: 'Polygon', coordinates: exportPolygon(geometry.coordinates) };
+        case 'MultiPoint':
+            return { type: 'MultiPoint', coordinates: exportLine(geometry.coordinates) };
+        case 'MultiLineString':
+            return {
+                type: 'MultiLineString',
+                coordinates: geometry.coordinates.map(exportLine),
+            };
+        case 'MultiPolygon':
+            return {
+                type: 'MultiPolygon',
+                coordinates: normalizeMultiPolygonOrientation(geometry.coordinates.map((rings) => rings.map(roundLine))).map(wrapRings),
+            };
+        default:
+            return null;
+    }
 }
 /**
  * Converts an internal Feature into a GeoJSON Feature
  *
- * Conforms to docs/reference/data-format.md:
- *   - includes the metadata in properties with the maplibre-gl-draw: prefix, and writes
- *     name and description as plain keys
- *   - rounds the positions and orients the rings (see the top of this file)
- *   - a Point is written out as a Point geometry
- *   - the Multi types (MultiPoint / MultiLineString / MultiPolygon) are written out as they are
- *   - an Image is written out as a Point geometry and identified by featureType
+ * Conforms to docs/reference/data-format.md. The geometry and the properties are written as
+ * they are: the values of this library already carry the maplibre-gl-draw: prefix, and name
+ * and description are plain keys. Besides:
+ *   - the fields of the feature (id, layer, group, visibility, lock, style) are added to the
+ *     properties with the maplibre-gl-draw: prefix
+ *   - the positions are rounded and the rings oriented (see the top of this file)
+ *   - a type that is not the type of its geometry is identified by featureType
  *   - for an Image feature, the image data is embedded as Base64
  */
 export function convertFeatureToGeoJSON(feature, store) {
     const properties = {};
-    // Add the properties (this library's own ones get the prefix). They are defined as
-    // own properties so that a `__proto__` key is written out instead of replacing the
-    // prototype of the output object.
+    // Add the properties as they are (the values of this library already carry the prefix).
+    // They are defined as own properties so that a `__proto__` key is written out instead of
+    // replacing the prototype of the output object.
     for (const [key, value] of Object.entries(feature.properties)) {
-        if (LIBRARY_PROPERTIES.has(key)) {
-            setOwnProperty(properties, `${GEOJSON_PREFIX}${key}`, value);
-        }
-        else {
-            setOwnProperty(properties, key, value);
-        }
+        setOwnProperty(properties, key, value);
     }
     // Add the metadata
-    properties[`${GEOJSON_PREFIX}id`] = feature.id;
-    properties[`${GEOJSON_PREFIX}layerId`] = feature.layerId;
+    properties[`${DRAW_PROPERTY_PREFIX}id`] = feature.id;
+    properties[`${DRAW_PROPERTY_PREFIX}layerId`] = feature.layerId;
     if (feature.groupId !== undefined) {
-        properties[`${GEOJSON_PREFIX}groupId`] = feature.groupId;
+        properties[`${DRAW_PROPERTY_PREFIX}groupId`] = feature.groupId;
     }
     if (!feature.visible) {
-        properties[`${GEOJSON_PREFIX}visible`] = false;
+        properties[`${DRAW_PROPERTY_PREFIX}visible`] = false;
     }
     if (feature.locked) {
-        properties[`${GEOJSON_PREFIX}locked`] = true;
+        properties[`${DRAW_PROPERTY_PREFIX}locked`] = true;
     }
-    if (feature.style) {
-        properties[`${GEOJSON_PREFIX}style`] = feature.style;
+    if (Object.keys(feature.style).length > 0) {
+        properties[`${DRAW_PROPERTY_PREFIX}style`] = feature.style;
     }
-    let geometry;
-    switch (feature.type) {
-        case 'Point':
-            geometry = { type: 'Point', coordinates: exportPosition(feature.coordinates) };
-            break;
-        case 'LineString':
-            geometry = { type: 'LineString', coordinates: exportLine(feature.coordinates) };
-            break;
-        case 'Polygon':
-            geometry = {
-                type: 'Polygon',
-                coordinates: exportPolygon(feature.coordinates),
-            };
-            break;
-        // The Multi types are written out to GeoJSON with their part structure preserved
-        case 'MultiPoint':
-            geometry = { type: 'MultiPoint', coordinates: exportLine(feature.coordinates) };
-            break;
-        case 'MultiLineString':
-            geometry = {
-                type: 'MultiLineString',
-                coordinates: feature.coordinates.map(exportLine),
-            };
-            break;
-        case 'MultiPolygon':
-            geometry = {
-                type: 'MultiPolygon',
-                coordinates: normalizeMultiPolygonOrientation(feature.coordinates.map((rings) => rings.map(roundLine))).map(wrapRings),
-            };
-            break;
-        case 'Image': {
-            // An Image is written out as a Point geometry and identified by featureType
-            geometry = { type: 'Point', coordinates: exportPosition(feature.coordinates) };
-            properties[`${GEOJSON_PREFIX}featureType`] = feature.type;
-            // Embed the image data as Base64
-            const imageFileId = feature.properties.imageFileId;
-            if (imageFileId) {
-                const fileData = store.getFile(imageFileId);
-                if (fileData) {
-                    properties[`${GEOJSON_PREFIX}imageData`] = fileData.dataURL;
-                    properties[`${GEOJSON_PREFIX}imageMimeType`] = fileData.mimeType;
-                }
-            }
-            break;
+    const geometry = exportGeometry(feature.geometry);
+    if (!geometry) {
+        console.warn(`Unsupported geometry for GeoJSON export: ${feature.geometry.type}`);
+        return null;
+    }
+    // A type that GeoJSON has no geometry for (Image, Circle, Freehand and custom types) makes
+    // the round trip through the featureType marker, which carries the type name as it is (a
+    // name such as MyShape keeps its inner capital). The import restores the type from it.
+    if (feature.type !== feature.geometry.type) {
+        properties[`${DRAW_PROPERTY_PREFIX}featureType`] = feature.type;
+    }
+    // Embed the image data of an Image as Base64
+    if (feature.type === 'Image') {
+        const imageFileId = getDrawProperty(feature, 'imageFileId');
+        const fileData = imageFileId ? store.getFile(imageFileId) : undefined;
+        if (fileData) {
+            properties[`${DRAW_PROPERTY_PREFIX}imageData`] = fileData.dataURL;
+            properties[`${DRAW_PROPERTY_PREFIX}imageMimeType`] = fileData.mimeType;
         }
-        default:
-            // Custom types (Circle, and the types registered from outside) are dispatched by the shape of their
-            // geometry, and the type itself makes the round trip through the featureType marker,
-            // which carries the type name as it is (a name such as MyShape keeps its inner capital).
-            // A type with a single point is written out as a Point, and a type with a sequence of
-            // points as a LineString. In both cases the import side restores
-            // the original type from the same marker.
-            if (isCoordinatePair(feature.coordinates)) {
-                geometry = { type: 'Point', coordinates: exportPosition(feature.coordinates) };
-                properties[`${GEOJSON_PREFIX}featureType`] = feature.type;
-            }
-            else if (isCoordinatePairArray(feature.coordinates)) {
-                geometry = {
-                    type: 'LineString',
-                    coordinates: exportLine(feature.coordinates),
-                };
-                properties[`${GEOJSON_PREFIX}featureType`] = feature.type;
-            }
-            else {
-                console.warn(`Unsupported feature type for GeoJSON export: ${feature.type}`);
-                return null;
-            }
     }
     return {
         type: 'Feature',
@@ -197,12 +164,12 @@ export function convertFeatureToGeoJSON(feature, store) {
  */
 export function exportGeoJSON(store, options) {
     // In addition to the draw order (visible), hidden features are also included at the end
-    // of the export. getOrderedFeatures returns only the visible features, so on its own it
+    // of the export. listShownFeatures returns only the visible features, so on its own it
     // would lose visible:false across the GeoJSON round trip. Including the hidden ones
     // preserves it across the round trip.
-    const visibleOrdered = store.getOrderedFeatures();
+    const visibleOrdered = listShownFeatures(store);
     const visibleIds = new Set(visibleOrdered.map((f) => f.id));
-    const hiddenFeatures = store.getAllFeatures().filter((f) => !visibleIds.has(f.id));
+    const hiddenFeatures = store.listFeatures().filter((f) => !visibleIds.has(f.id));
     let features = [...visibleOrdered, ...hiddenFeatures];
     if (options?.featureIds && options.featureIds.length > 0) {
         const featureIdSet = new Set(options.featureIds);

package/dist/api/{import-export → impl/import-export}/geojson-import.d.ts

@@ -1,7 +1,7 @@
-import type { AutoNameGenerator } from '../../shared/utils/name-generator.js';
-import type { Store } from '../../store/store.js';
-import type { LoadResult, SkippedFeature } from '../../store/types.js';
-import type { ConvertedFeatureResult, GeoJSONImportOptions } from './types.js';
+import type { AutoNameGenerator } from '../../../shared/utils/name-generator.js';
+import type { Store } from '../../../store/store.js';
+import type { LoadResult, SkippedFeature } from '../../../store/types.js';
+import type { ConvertedFeatureResult, GeoJSONImportOptions, PreparedLoad } from './types.js';
 /** A GeoJSON feature that the import left out, with the reason */
 /** The result of a GeoJSON import */
 export interface GeoJSONLoadResult extends LoadResult {
@@ -24,11 +24,15 @@ export declare function convertGeoJSONToFeature(geoFeature: unknown, layerId: st
     reason: string;
 };
 /**
- * Imports a GeoJSON FeatureCollection (adds to the existing data)
+ * Reads a GeoJSON FeatureCollection for a load that adds to the existing data (or replaces
+ * the features and groups): the features are converted and checked and the embedded images
+ * decoded here, and the writes are left to the transaction of the caller. The IDs and the
+ * references to layers and groups are resolved when the features are written, against the
+ * document as it is then (another load of the same transaction may have changed it).
  */
-export declare function loadGeoJSON(data: GeoJSON.FeatureCollection<GeoJSON.Geometry>, deps: {
+export declare function prepareGeoJSON(data: GeoJSON.FeatureCollection<GeoJSON.Geometry>, deps: {
     store: Store;
     autoNameGenerator: AutoNameGenerator;
     generateFeatureId: () => string;
     getCurrentLayerId: () => string;
-}, options?: GeoJSONImportOptions): Promise<GeoJSONLoadResult>;
+}, options?: GeoJSONImportOptions): Promise<PreparedLoad>;