@chelone/core 0.5.0 → 0.7.0

package/dist/geo/editor.js

@@ -1,168 +1,191 @@
+import { isJsonObject } from "../guards.js";
 import { isGeoGeometry } from "./geojson.js";
-const EDITOR_PROPERTIES = {
-  mode: "mode",
-  currentlyDrawing: "currentlyDrawing",
-  edited: "edited",
-  closingPoint: "closingPoint",
-  snappingPoint: "snappingPoint",
-  coordinatePoint: "coordinatePoint",
-  coordinatePointFeatureId: "coordinatePointFeatureId",
-  coordinatePointIds: "coordinatePointIds",
-  provisionalCoordinateCount: "provisionalCoordinateCount",
-  committedCoordinateCount: "committedCoordinateCount",
-  marker: "marker",
-  selected: "selected",
-  midPoint: "midPoint",
-  selectionPointFeatureId: "selectionPointFeatureId",
-  selectionPoint: "selectionPoint"
+// src/geo/editor.ts
+var EDITOR_PROPERTIES = {
+	mode: "mode",
+	currentlyDrawing: "currentlyDrawing",
+	edited: "edited",
+	closingPoint: "closingPoint",
+	snappingPoint: "snappingPoint",
+	coordinatePoint: "coordinatePoint",
+	coordinatePointFeatureId: "coordinatePointFeatureId",
+	coordinatePointIds: "coordinatePointIds",
+	provisionalCoordinateCount: "provisionalCoordinateCount",
+	committedCoordinateCount: "committedCoordinateCount",
+	marker: "marker",
+	selected: "selected",
+	midPoint: "midPoint",
+	selectionPointFeatureId: "selectionPointFeatureId",
+	selectionPoint: "selectionPoint"
 };
-const HELPER_FLAGS = [
-  EDITOR_PROPERTIES.selectionPoint,
-  EDITOR_PROPERTIES.midPoint,
-  EDITOR_PROPERTIES.closingPoint,
-  EDITOR_PROPERTIES.snappingPoint,
-  EDITOR_PROPERTIES.coordinatePoint,
-  EDITOR_PROPERTIES.currentlyDrawing
+/** Flags that mark a feature the editor made for itself, not the user's shape. */
+var HELPER_FLAGS = [
+	EDITOR_PROPERTIES.selectionPoint,
+	EDITOR_PROPERTIES.midPoint,
+	EDITOR_PROPERTIES.closingPoint,
+	EDITOR_PROPERTIES.snappingPoint,
+	EDITOR_PROPERTIES.coordinatePoint,
+	EDITOR_PROPERTIES.currentlyDrawing
 ];
-const EDITOR_OWN_PROPERTIES = [
-  ...Object.values(EDITOR_PROPERTIES),
-  "radiusKilometers"
-];
-const SOURCE_ID = "chelone:id";
-const SOURCE_PROPERTIES = "chelone:properties";
-const MODES = {
-  Point: "point",
-  LineString: "linestring",
-  Polygon: "polygon"
+/**
+* Properties the editor adds to a user's own feature. `radiusKilometers` is
+* written by its circle mode and is a literal in its source, not a constant.
+*/
+var EDITOR_OWN_PROPERTIES = [...Object.values(EDITOR_PROPERTIES), "radiusKilometers"];
+/** Where the editor keeps the id a feature had before it went in. */
+var SOURCE_ID = "chelone:id";
+/**
+* Where the editor keeps the properties a feature had before it went in, so
+* none of them can be mistaken for its own flags.
+*/
+var SOURCE_PROPERTIES = "chelone:properties";
+var MODES = {
+	Point: "point",
+	LineString: "linestring",
+	Polygon: "polygon"
 };
-const EDITOR_DECIMALS = 9;
-function editorPosition([longitude, latitude]) {
-  const wrapped = longitude >= -180 && longitude <= 180 ? longitude : ((longitude + 180) % 360 + 360) % 360 - 180;
-  return [
-    Number(wrapped.toFixed(EDITOR_DECIMALS)) + 0,
-    Number(latitude.toFixed(EDITOR_DECIMALS)) + 0
-  ];
+/** Decimals the editor accepts in a position. */
+var EDITOR_DECIMALS = 9;
+/**
+* A position as the editor accepts it: longitude wrapped into -180 to 180,
+* both numbers rounded to 9 decimals, and any altitude dropped.
+*/
+function editorPosition([longitude = NaN, latitude = NaN]) {
+	const wrapped = longitude >= -180 && longitude <= 180 ? longitude : ((longitude + 180) % 360 + 360) % 360 - 180;
+	return [Number(wrapped.toFixed(EDITOR_DECIMALS)) + 0, Number(latitude.toFixed(EDITOR_DECIMALS)) + 0];
 }
 function editorGeometry(geometry) {
-  switch (geometry.type) {
-    case "Point":
-      return { ...geometry, coordinates: editorPosition(geometry.coordinates) };
-    case "LineString":
-      return {
-        ...geometry,
-        coordinates: geometry.coordinates.map(editorPosition)
-      };
-    case "Polygon":
-      return {
-        ...geometry,
-        coordinates: geometry.coordinates.map(
-          (ring) => ring.map(editorPosition)
-        )
-      };
-  }
+	switch (geometry.type) {
+		case "Point": return {
+			...geometry,
+			coordinates: editorPosition(geometry.coordinates)
+		};
+		case "LineString": return {
+			...geometry,
+			coordinates: geometry.coordinates.map(editorPosition)
+		};
+		case "Polygon": return {
+			...geometry,
+			coordinates: geometry.coordinates.map((ring) => ring.map(editorPosition))
+		};
+	}
 }
+/**
+* Copies of the features the editor can hold, each with a fresh `id` from
+* `getId` and a `properties.mode` naming its drawing mode. The editor refuses
+* an id its own strategy did not make, so the source `id` moves to
+* `properties["chelone:id"]`, and the source properties move whole to
+* `properties["chelone:properties"]`. Features it cannot hold are left out.
+* The editor refuses a position with more than 9 decimals, an altitude or a
+* longitude outside -180 to 180, so each copy's positions are rounded to 9
+* decimals, cut to longitude and latitude, and wrapped. The source is not
+* rewritten.
+*/
 function toEditorFeatures(features, getId) {
-  const result = [];
-  for (const feature of features) {
-    const geometry = feature.geometry;
-    if (!geometry || geometry.type !== "Point" && geometry.type !== "LineString" && geometry.type !== "Polygon" || geometry.type === "Polygon" && geometry.coordinates.length !== 1) {
-      continue;
-    }
-    const properties = {
-      mode: MODES[geometry.type],
-      [SOURCE_PROPERTIES]: { ...feature.properties }
-    };
-    if (feature.id !== void 0) properties[SOURCE_ID] = feature.id;
-    result.push({
-      type: "Feature",
-      id: getId(),
-      geometry: editorGeometry(geometry),
-      properties
-    });
-  }
-  return result;
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+	const result = [];
+	for (const feature of features) {
+		const geometry = feature.geometry;
+		if (!geometry || geometry.type !== "Point" && geometry.type !== "LineString" && geometry.type !== "Polygon" || geometry.type === "Polygon" && geometry.coordinates.length !== 1) continue;
+		const properties = {
+			mode: MODES[geometry.type],
+			[SOURCE_PROPERTIES]: { ...feature.properties }
+		};
+		if (feature.id !== void 0) properties[SOURCE_ID] = feature.id;
+		result.push({
+			type: "Feature",
+			id: getId(),
+			geometry: editorGeometry(geometry),
+			properties
+		});
+	}
+	return result;
 }
+/**
+* The user's features in an editor snapshot: its helper features (selection
+* points, midpoints, closing points, snapping points and a feature still being
+* drawn) are dropped, and `id` and `properties` come back from `chelone:id`
+* and `chelone:properties`. A feature the editor made has no `id`, and keeps
+* its properties but for the editor's own. A feature with a coordinate that is
+* not a finite number, or a `chelone:properties` that is not a JSON object, is
+* left out.
+*/
 function fromEditorFeatures(snapshot) {
-  const result = [];
-  for (const entry of snapshot) {
-    const source = { ...entry.properties };
-    if (HELPER_FLAGS.some((flag) => source[flag])) continue;
-    if (!isGeoGeometry(entry.geometry)) continue;
-    const kept = source[SOURCE_PROPERTIES];
-    const properties = isPlainObject(kept) ? { ...kept } : Object.fromEntries(
-      Object.entries(source).filter(
-        ([key]) => key !== SOURCE_ID && key !== SOURCE_PROPERTIES && !EDITOR_OWN_PROPERTIES.includes(key)
-      )
-    );
-    const feature = {
-      type: "Feature",
-      geometry: entry.geometry,
-      properties
-    };
-    const id = source[SOURCE_ID];
-    if (typeof id === "string" || typeof id === "number") feature.id = id;
-    result.push(feature);
-  }
-  return result;
+	const result = [];
+	for (const entry of snapshot) {
+		const source = { ...entry.properties };
+		if (HELPER_FLAGS.some((flag) => source[flag])) continue;
+		if (!isGeoGeometry(entry.geometry)) continue;
+		const kept = source[SOURCE_PROPERTIES];
+		if (SOURCE_PROPERTIES in source && !isJsonObject(kept)) continue;
+		const properties = isJsonObject(kept) ? { ...kept } : Object.fromEntries(Object.entries(source).filter(([key]) => key !== SOURCE_ID && key !== SOURCE_PROPERTIES && !EDITOR_OWN_PROPERTIES.includes(key)));
+		const feature = {
+			type: "Feature",
+			geometry: entry.geometry,
+			properties
+		};
+		const id = source[SOURCE_ID];
+		if (typeof id === "string" || typeof id === "number") feature.id = id;
+		result.push(feature);
+	}
+	return result;
 }
+/** Keeps the keys whose value is set. */
 function defined(entries) {
-  const result = {};
-  for (const [key, value] of Object.entries(entries)) {
-    if (value !== void 0) result[key] = value;
-  }
-  return result;
+	const result = {};
+	for (const [key, value] of Object.entries(entries)) if (value !== void 0) result[key] = value;
+	return result;
 }
+/**
+* Maps a {@link ShapeStyle} onto the style keys of each Terra Draw mode. A key
+* with no value in `style` is left out so the mode keeps its own default.
+* `pointRadius` becomes a width, the diameter.
+*/
 function editorStyles(style) {
-  const fill = style.fillColor ?? style.color;
-  const width = style.pointRadius === void 0 ? void 0 : style.pointRadius * 2;
-  const area = defined({
-    fillColor: fill,
-    fillOpacity: style.fillOpacity,
-    outlineColor: style.color,
-    outlineWidth: style.weight,
-    outlineOpacity: style.opacity
-  });
-  return {
-    point: defined({ pointColor: style.pointColor, pointWidth: width }),
-    linestring: defined({
-      lineStringColor: style.color,
-      lineStringWidth: style.weight,
-      lineStringOpacity: style.opacity
-    }),
-    polygon: area,
-    rectangle: { ...area },
-    circle: { ...area },
-    render: defined({
-      pointColor: style.pointColor,
-      pointWidth: width,
-      lineStringColor: style.color,
-      lineStringWidth: style.weight,
-      lineStringOpacity: style.opacity,
-      polygonFillColor: fill,
-      polygonFillOpacity: style.fillOpacity,
-      polygonOutlineColor: style.color,
-      polygonOutlineWidth: style.weight
-    }),
-    select: defined({
-      selectedPointColor: style.pointColor,
-      selectedPointWidth: width,
-      selectedLineStringColor: style.color,
-      selectedLineStringWidth: style.weight,
-      selectedLineStringOpacity: style.opacity,
-      selectedPolygonColor: fill,
-      selectedPolygonFillOpacity: style.fillOpacity,
-      selectedPolygonOutlineColor: style.color,
-      selectedPolygonOutlineWidth: style.weight,
-      selectedPolygonOutlineOpacity: style.opacity
-    })
-  };
+	const fill = style.fillColor ?? style.color;
+	const width = style.pointRadius === void 0 ? void 0 : style.pointRadius * 2;
+	const area = defined({
+		fillColor: fill,
+		fillOpacity: style.fillOpacity,
+		outlineColor: style.color,
+		outlineWidth: style.weight,
+		outlineOpacity: style.opacity
+	});
+	return {
+		point: defined({
+			pointColor: style.pointColor,
+			pointWidth: width
+		}),
+		linestring: defined({
+			lineStringColor: style.color,
+			lineStringWidth: style.weight,
+			lineStringOpacity: style.opacity
+		}),
+		polygon: area,
+		rectangle: { ...area },
+		circle: { ...area },
+		render: defined({
+			pointColor: style.pointColor,
+			pointWidth: width,
+			lineStringColor: style.color,
+			lineStringWidth: style.weight,
+			lineStringOpacity: style.opacity,
+			polygonFillColor: fill,
+			polygonFillOpacity: style.fillOpacity,
+			polygonOutlineColor: style.color,
+			polygonOutlineWidth: style.weight
+		}),
+		select: defined({
+			selectedPointColor: style.pointColor,
+			selectedPointWidth: width,
+			selectedLineStringColor: style.color,
+			selectedLineStringWidth: style.weight,
+			selectedLineStringOpacity: style.opacity,
+			selectedPolygonColor: fill,
+			selectedPolygonFillOpacity: style.fillOpacity,
+			selectedPolygonOutlineColor: style.color,
+			selectedPolygonOutlineWidth: style.weight,
+			selectedPolygonOutlineOpacity: style.opacity
+		})
+	};
 }
-export {
-  EDITOR_PROPERTIES,
-  editorStyles,
-  fromEditorFeatures,
-  toEditorFeatures
-};
+export { EDITOR_PROPERTIES, editorStyles, fromEditorFeatures, toEditorFeatures };

package/dist/geo/geocoding.d.ts

@@ -1,11 +1,11 @@
 import type { QueryFunctionContext } from "@tanstack/query-core";
-import type { GeoBBox } from "./geojson.js";
+import type { LngLatBox } from "./bounds.js";
 export interface GeocodeResult {
     displayName: string;
     lat: number;
     lng: number;
     /** `[west, south, east, north]`. */
-    bbox?: GeoBBox;
+    bbox?: LngLatBox;
     /** The service's own kind of place, such as `city` or `house`. */
     type?: string;
     /** The service's unmapped hit, for fields core does not model. */
@@ -19,7 +19,7 @@ export interface GeocodeSearchOptions extends GeocodeRequestOptions {
     /** ISO 3166-1 alpha-2 codes to restrict the search to. */
     countryCodes?: string[];
     /** `[west, south, east, north]` to favour or restrict hits to. */
-    viewBox?: GeoBBox;
+    viewBox?: LngLatBox;
 }
 export interface GeocodingProvider {
     name: string;
@@ -45,7 +45,7 @@ export interface GeocodeQueryOptions extends ReverseGeocodeQueryOptions {
     minChars?: number;
     limit?: number;
     countryCodes?: string[];
-    viewBox?: GeoBBox;
+    viewBox?: LngLatBox;
 }
 export interface GeocodeQuery<TData> {
     queryKey: readonly unknown[];

package/dist/geo/geocoding.js

@@ -1,45 +1,42 @@
-const FIVE_MINUTES_MS = 5 * 60 * 1e3;
+// src/geo/geocoding.ts
+var FIVE_MINUTES_MS = 3e5;
+/** Query options for `useQuery`; the query's `signal` reaches the provider. */
 function geocodeQueryOptions(provider, query, options = {}) {
-  const {
-    minChars = 3,
-    limit,
-    countryCodes,
-    viewBox,
-    staleTime = FIVE_MINUTES_MS
-  } = options;
-  const trimmed = query.trim();
-  return {
-    queryKey: [
-      "geocode",
-      provider.cacheKey ?? provider.name,
-      trimmed,
-      countryCodes ?? null,
-      viewBox ?? null,
-      limit ?? null
-    ],
-    queryFn: ({ signal }) => provider.search(trimmed, { signal, limit, countryCodes, viewBox }),
-    enabled: trimmed.length >= minChars,
-    staleTime,
-    // A rate-limited public service is not hit again; the caller reports the failure.
-    retry: false
-  };
+	const { minChars = 3, limit, countryCodes, viewBox, staleTime = FIVE_MINUTES_MS } = options;
+	const trimmed = query.trim();
+	return {
+		queryKey: [
+			"geocode",
+			provider.cacheKey ?? provider.name,
+			trimmed,
+			countryCodes ?? null,
+			viewBox ?? null,
+			limit ?? null
+		],
+		queryFn: ({ signal }) => provider.search(trimmed, {
+			signal,
+			limit,
+			countryCodes,
+			viewBox
+		}),
+		enabled: trimmed.length >= minChars,
+		staleTime,
+		retry: false
+	};
 }
-const round5 = (value) => Math.round(value * 1e5) / 1e5;
+var round5 = (value) => Math.round(value * 1e5) / 1e5;
 function reverseGeocodeQueryOptions(provider, position, options = {}) {
-  const { lat, lng } = position;
-  return {
-    queryKey: [
-      "reverse-geocode",
-      provider.cacheKey ?? provider.name,
-      round5(lat),
-      round5(lng)
-    ],
-    queryFn: ({ signal }) => provider.reverse(lat, lng, { signal }),
-    enabled: Number.isFinite(lat) && Number.isFinite(lng),
-    staleTime: options.staleTime ?? FIVE_MINUTES_MS
-  };
+	const { lat, lng } = position;
+	return {
+		queryKey: [
+			"reverse-geocode",
+			provider.cacheKey ?? provider.name,
+			round5(lat),
+			round5(lng)
+		],
+		queryFn: ({ signal }) => provider.reverse(lat, lng, { signal }),
+		enabled: Number.isFinite(lat) && Number.isFinite(lng),
+		staleTime: options.staleTime ?? FIVE_MINUTES_MS
+	};
 }
-export {
-  geocodeQueryOptions,
-  reverseGeocodeQueryOptions
-};
+export { geocodeQueryOptions, reverseGeocodeQueryOptions };

package/dist/geo/geojson.d.ts

@@ -1,75 +1,13 @@
-/** `[longitude, latitude]` with an optional altitude and further members. */
-export type GeoPosition = [
-    longitude: number,
-    latitude: number,
-    ...rest: number[]
-];
-/** `[west, south, east, north]`. */
-export type GeoBBox = [
-    west: number,
-    south: number,
-    east: number,
-    north: number
-];
-/** `[west, south, min altitude, east, north, max altitude]`. */
-export type GeoBBox3D = [
-    west: number,
-    south: number,
-    minAltitude: number,
-    east: number,
-    north: number,
-    maxAltitude: number
-];
-interface GeoGeometryBase {
-    bbox?: GeoBBox | GeoBBox3D;
-}
-export interface GeoPoint extends GeoGeometryBase {
-    type: "Point";
-    coordinates: GeoPosition;
-}
-export interface GeoMultiPoint extends GeoGeometryBase {
-    type: "MultiPoint";
-    coordinates: GeoPosition[];
-}
-export interface GeoLineString extends GeoGeometryBase {
-    type: "LineString";
-    coordinates: GeoPosition[];
-}
-export interface GeoMultiLineString extends GeoGeometryBase {
-    type: "MultiLineString";
-    coordinates: GeoPosition[][];
-}
-export interface GeoPolygon extends GeoGeometryBase {
-    type: "Polygon";
-    coordinates: GeoPosition[][];
-}
-export interface GeoMultiPolygon extends GeoGeometryBase {
-    type: "MultiPolygon";
-    coordinates: GeoPosition[][][];
-}
-export interface GeoGeometryCollection extends GeoGeometryBase {
-    type: "GeometryCollection";
-    geometries: GeoGeometry[];
-}
-export type GeoGeometry = GeoPoint | GeoMultiPoint | GeoLineString | GeoMultiLineString | GeoPolygon | GeoMultiPolygon | GeoGeometryCollection;
-export interface GeoFeature {
-    type: "Feature";
-    geometry: GeoGeometry | null;
-    properties: Record<string, unknown> | null;
-    id?: string | number;
-    bbox?: GeoBBox | GeoBBox3D;
-}
-export interface GeoFeatureCollection {
-    type: "FeatureCollection";
-    features: GeoFeature[];
-    bbox?: GeoBBox | GeoBBox3D;
-}
-/** What a map input stores: a geometry, a Feature or a FeatureCollection. */
-export type GeoJsonValue = GeoGeometry | GeoFeature | GeoFeatureCollection;
+import type { Feature, FeatureCollection, Geometry, MultiPolygon, Polygon } from "geojson";
+import { type JsonObject } from "../guards.js";
+export type { Feature, FeatureCollection, Geometry } from "geojson";
 /** True for exactly four finite numbers. */
-export declare function isGeoBBox(value: unknown): value is GeoBBox;
-export declare function isGeoGeometry(value: unknown): value is GeoGeometry;
-export declare function isGeoFeature(value: unknown): value is GeoFeature;
-export declare function isGeoFeatureCollection(value: unknown): value is GeoFeatureCollection;
-export declare function isGeoJsonValue(value: unknown): value is GeoJsonValue;
-export {};
+export declare function isGeoBBox(value: unknown): value is [number, number, number, number];
+export declare function isGeoGeometry(value: unknown): value is Geometry;
+/** A Polygon or a MultiPolygon, the geometries turf's area operations take. */
+export declare function isGeoArea(value: unknown): value is Polygon | MultiPolygon;
+export declare function isGeoFeature(value: unknown): value is Feature<Geometry | null, JsonObject | null>;
+export declare function isGeoFeatureCollection(value: unknown): value is FeatureCollection<Geometry | null, JsonObject | null>;
+export declare function isGeoJsonValue(value: unknown): value is Geometry | Feature<Geometry | null, JsonObject | null> | FeatureCollection<Geometry | null, JsonObject | null>;
+/** The features MapLibre draws: a feature with a null geometry has nothing to draw. */
+export declare function placedFeatures(collection: FeatureCollection<Geometry | null, JsonObject | null>): FeatureCollection<Geometry, JsonObject | null>;