@chelone/core 0.6.0 → 0.7.0

package/dist/geo/bounds.js

@@ -1,74 +1,104 @@
-const MAX_LONGITUDE = 540;
+// src/geo/bounds.ts
+var MAX_LONGITUDE = 540;
+/**
+* The `[west, east]` arc over `longitudes`, which wraps (west greater than
+* east) when going round the antimeridian is narrower. Left plain when a value
+* is no longitude, such as a projected coordinate.
+*/
 function longitudeArc(longitudes, west, east, mode) {
-  if (east <= 180 && (mode === "explicit" || east - west <= 180)) {
-    return [west, east];
-  }
-  const wrapped = /* @__PURE__ */ new Set();
-  for (const longitude of longitudes) {
-    if (longitude < -180 || longitude > MAX_LONGITUDE) return [west, east];
-    wrapped.add(longitude > 180 ? longitude - 360 : longitude);
-  }
-  const sorted = [...wrapped].sort((x, y) => x - y);
-  const min = sorted[0] ?? west;
-  const max = sorted[sorted.length - 1] ?? east;
-  let widest = 360 - (max - min);
-  if (widest <= 0) return [min, max];
-  let arc = [min, max];
-  sorted.forEach((longitude, i) => {
-    const gap = longitude - (sorted[i - 1] ?? longitude);
-    if (gap > widest) {
-      widest = gap;
-      arc = [longitude, sorted[i - 1] ?? longitude];
-    }
-  });
-  return arc;
+	if (east <= 180 && (mode === "explicit" || east - west <= 180)) return [west, east];
+	const wrapped = /* @__PURE__ */ new Set();
+	for (const longitude of longitudes) {
+		if (longitude < -180 || longitude > MAX_LONGITUDE) return [west, east];
+		wrapped.add(longitude > 180 ? longitude - 360 : longitude);
+	}
+	const sorted = [...wrapped].sort((x, y) => x - y);
+	const min = sorted[0] ?? west;
+	const max = sorted[sorted.length - 1] ?? east;
+	let widest = 360 - (max - min);
+	if (widest <= 0) return [min, max];
+	let arc = [min, max];
+	sorted.forEach((longitude, i) => {
+		const gap = longitude - (sorted[i - 1] ?? longitude);
+		if (gap > widest) {
+			widest = gap;
+			arc = [longitude, sorted[i - 1] ?? longitude];
+		}
+	});
+	return arc;
 }
+/**
+* `[west, south, east, north]` over every position of a geometry, Feature or
+* FeatureCollection; `null` when there is none. Altitude is ignored. When the
+* longitudes are narrower going round the antimeridian, west is greater than
+* east.
+*/
 function geoBounds(value, mode = "narrowest") {
-  let bounds = null;
-  const longitudes = /* @__PURE__ */ new Set();
-  const extend = (longitude, latitude) => {
-    longitudes.add(longitude);
-    if (!bounds) {
-      bounds = [longitude, latitude, longitude, latitude];
-      return;
-    }
-    bounds[0] = Math.min(bounds[0], longitude);
-    bounds[1] = Math.min(bounds[1], latitude);
-    bounds[2] = Math.max(bounds[2], longitude);
-    bounds[3] = Math.max(bounds[3], latitude);
-  };
-  const walkCoordinates = (node) => {
-    if (!Array.isArray(node)) return;
-    if (typeof node[0] === "number") {
-      extend(node[0], node[1]);
-      return;
-    }
-    for (const child of node) walkCoordinates(child);
-  };
-  const walk = (node) => {
-    if (!node) return;
-    if (node.type === "FeatureCollection") {
-      for (const feature of node.features) walk(feature);
-    } else if (node.type === "Feature") {
-      walk(node.geometry);
-    } else if (node.type === "GeometryCollection") {
-      for (const geometry of node.geometries) walk(geometry);
-    } else {
-      walkCoordinates(node.coordinates);
-    }
-  };
-  walk(value);
-  if (!bounds) return null;
-  const [west, south, east, north] = bounds;
-  const [arcWest, arcEast] = longitudeArc(longitudes, west, east, mode);
-  return [arcWest, south, arcEast, north];
+	const state = { box: null };
+	const longitudes = /* @__PURE__ */ new Set();
+	const extend = (position) => {
+		const [longitude, latitude] = position;
+		if (longitude === void 0 || latitude === void 0) return;
+		longitudes.add(longitude);
+		const box = state.box;
+		if (!box) {
+			state.box = [
+				longitude,
+				latitude,
+				longitude,
+				latitude
+			];
+			return;
+		}
+		box[0] = Math.min(box[0], longitude);
+		box[1] = Math.min(box[1], latitude);
+		box[2] = Math.max(box[2], longitude);
+		box[3] = Math.max(box[3], latitude);
+	};
+	const walk = (node) => {
+		if (!node) return;
+		switch (node.type) {
+			case "FeatureCollection":
+				for (const feature of node.features) walk(feature);
+				break;
+			case "Feature":
+				walk(node.geometry);
+				break;
+			case "GeometryCollection":
+				for (const geometry of node.geometries) walk(geometry);
+				break;
+			case "Point":
+				extend(node.coordinates);
+				break;
+			case "MultiPoint":
+			case "LineString":
+				for (const position of node.coordinates) extend(position);
+				break;
+			case "MultiLineString":
+			case "Polygon":
+				for (const line of node.coordinates) for (const position of line) extend(position);
+				break;
+			case "MultiPolygon": for (const polygon of node.coordinates) for (const ring of polygon) for (const position of ring) extend(position);
+		}
+	};
+	walk(value);
+	if (!state.box) return null;
+	const [west, south, east, north] = state.box;
+	const [arcWest, arcEast] = longitudeArc(longitudes, west, east, mode);
+	return [
+		arcWest,
+		south,
+		arcEast,
+		north
+	];
 }
+/**
+* Whether every corner is a valid longitude and latitude. MapLibre throws on a
+* latitude outside ±90, so a box failing this is never fitted.
+*/
 function isLngLatBox(box) {
-  if (!box) return false;
-  const [west = 0, south = 0, east = 0, north = 0] = box;
-  return Math.abs(west) <= 180 && Math.abs(east) <= 180 && Math.abs(south) <= 90 && Math.abs(north) <= 90;
+	if (!box) return false;
+	const [west = 0, south = 0, east = 0, north = 0] = box;
+	return Math.abs(west) <= 180 && Math.abs(east) <= 180 && Math.abs(south) <= 90 && Math.abs(north) <= 90;
 }
-export {
-  geoBounds,
-  isLngLatBox
-};
+export { geoBounds, isLngLatBox };

package/dist/geo/constraints.js

@@ -1,121 +1,116 @@
 import { isEmpty } from "../form/validators.js";
+import { isRecord } from "../guards.js";
 import { bboxToPolygon } from "./bbox.js";
 import { isGeoJsonValue } from "./geojson.js";
 import { geoAreaM2, hasSelfIntersection } from "./geometry-math.js";
+// src/geo/constraints.ts
+/**
+* The geometry of each member of a geometry, Feature or FeatureCollection. A
+* BBox is the rectangle it covers.
+*/
 function members(value) {
-  const box = bboxToPolygon(value);
-  if (box) return [box];
-  if (!isGeoJsonValue(value)) return [];
-  if (value.type === "FeatureCollection") {
-    return value.features.flatMap((feature) => members(feature));
-  }
-  if (value.type === "Feature") return value.geometry ? [value.geometry] : [];
-  return [value];
+	const box = bboxToPolygon(value);
+	if (box) return [box];
+	if (!isGeoJsonValue(value)) return [];
+	if (value.type === "FeatureCollection") return value.features.flatMap((feature) => members(feature));
+	if (value.type === "Feature") return value.geometry ? [value.geometry] : [];
+	return [value];
 }
 function ringVertices(ring) {
-  const first = ring[0];
-  const last = ring[ring.length - 1];
-  const closed = ring.length > 1 && first !== void 0 && last !== void 0 && first[0] === last[0] && first[1] === last[1];
-  return closed ? ring.length - 1 : ring.length;
+	const first = ring[0];
+	const last = ring[ring.length - 1];
+	return ring.length > 1 && first !== void 0 && last !== void 0 && first[0] === last[0] && first[1] === last[1] ? ring.length - 1 : ring.length;
 }
 function geometryVertices(geometry) {
-  switch (geometry.type) {
-    case "Point":
-      return 1;
-    case "MultiPoint":
-    case "LineString":
-      return geometry.coordinates.length;
-    case "MultiLineString":
-      return geometry.coordinates.reduce((sum, line) => sum + line.length, 0);
-    case "Polygon":
-      return geometry.coordinates.reduce(
-        (sum, ring) => sum + ringVertices(ring),
-        0
-      );
-    case "MultiPolygon":
-      return geometry.coordinates.reduce(
-        (sum, polygon) => sum + polygon.reduce((inner, ring) => inner + ringVertices(ring), 0),
-        0
-      );
-    case "GeometryCollection":
-      return geometry.geometries.reduce(
-        (sum, part) => sum + geometryVertices(part),
-        0
-      );
-  }
+	switch (geometry.type) {
+		case "Point": return 1;
+		case "MultiPoint":
+		case "LineString": return geometry.coordinates.length;
+		case "MultiLineString": return geometry.coordinates.reduce((sum, line) => sum + line.length, 0);
+		case "Polygon": return geometry.coordinates.reduce((sum, ring) => sum + ringVertices(ring), 0);
+		case "MultiPolygon": return geometry.coordinates.reduce((sum, polygon) => sum + polygon.reduce((inner, ring) => inner + ringVertices(ring), 0), 0);
+		case "GeometryCollection": return geometry.geometries.reduce((sum, part) => sum + geometryVertices(part), 0);
+	}
 }
+/**
+* Vertices of a geometry, Feature, FeatureCollection or BBox. A polygon ring counts
+* its distinct vertices, so a triangle is 3. `0` for anything else.
+*/
 function countVertices(value) {
-  return members(value).reduce(
-    (sum, geometry) => sum + geometryVertices(geometry),
-    0
-  );
+	return members(value).reduce((sum, geometry) => sum + geometryVertices(geometry), 0);
 }
+/** Area of a geometry, with the parts of a GeometryCollection added up. */
 function areaM2(geometry) {
-  return geometry.type === "GeometryCollection" ? geometry.geometries.reduce((sum, part) => sum + areaM2(part), 0) : geoAreaM2(geometry);
+	return geometry.type === "GeometryCollection" ? geometry.geometries.reduce((sum, part) => sum + areaM2(part), 0) : geoAreaM2(geometry);
 }
 function hasArea(geometry) {
-  switch (geometry.type) {
-    case "Polygon":
-    case "MultiPolygon":
-      return true;
-    case "GeometryCollection":
-      return geometry.geometries.some(hasArea);
-    default:
-      return false;
-  }
+	switch (geometry.type) {
+		case "Polygon":
+		case "MultiPolygon": return true;
+		case "GeometryCollection": return geometry.geometries.some(hasArea);
+		default: return false;
+	}
 }
+/**
+* A Feature or FeatureCollection that `isGeoJsonValue` refuses. Its limits
+* cannot be checked, so a constraint fails it instead of passing it. Any other
+* value that is not GeoJSON is left to other validators.
+*/
 function isUnreadable(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const { type } = value;
-  return (type === "Feature" || type === "FeatureCollection") && !isGeoJsonValue(value);
+	return isRecord(value) && (value.type === "Feature" || value.type === "FeatureCollection") && !isGeoJsonValue(value);
 }
+/**
+* Each constraint skips empty values and a value that is not GeoJSON, fails a
+* Feature or FeatureCollection it cannot read, and fails when any member of a
+* FeatureCollection fails.
+*/
 function constraint(fails, failure) {
-  return (value) => {
-    if (isEmpty(value)) return void 0;
-    if (isUnreadable(value)) return failure();
-    return members(value).some(fails) ? failure() : void 0;
-  };
+	return (value) => {
+		if (isEmpty(value)) return void 0;
+		if (isUnreadable(value)) return failure();
+		return members(value).some(fails) ? failure() : void 0;
+	};
 }
 function minVertices(min) {
-  return constraint(
-    (geometry) => geometryVertices(geometry) < min,
-    () => ({ message: "chelone.validation.minVertices", args: { min } })
-  );
+	return constraint((geometry) => geometryVertices(geometry) < min, () => ({
+		message: "chelone.validation.minVertices",
+		args: { min }
+	}));
 }
 function maxVertices(max) {
-  return constraint(
-    (geometry) => geometryVertices(geometry) > max,
-    () => ({ message: "chelone.validation.maxVertices", args: { max } })
-  );
+	return constraint((geometry) => geometryVertices(geometry) > max, () => ({
+		message: "chelone.validation.maxVertices",
+		args: { max }
+	}));
 }
+/**
+* Fails a member with a polygon whose area is under `min` square metres. A
+* member with no polygon in it has no area and passes. `args.area` is rounded.
+*/
 function minAreaM2(min) {
-  return (value) => {
-    if (isEmpty(value)) return void 0;
-    if (isUnreadable(value)) {
-      return { message: "chelone.validation.minArea", args: { min, area: 0 } };
-    }
-    for (const geometry of members(value)) {
-      if (!hasArea(geometry)) continue;
-      const area = areaM2(geometry);
-      if (area < min) {
-        return {
-          message: "chelone.validation.minArea",
-          args: { min, area: Math.round(area) }
-        };
-      }
-    }
-    return void 0;
-  };
+	return (value) => {
+		if (isEmpty(value)) return void 0;
+		if (isUnreadable(value)) return {
+			message: "chelone.validation.minArea",
+			args: {
+				min,
+				area: 0
+			}
+		};
+		for (const geometry of members(value)) {
+			if (!hasArea(geometry)) continue;
+			const area = areaM2(geometry);
+			if (area < min) return {
+				message: "chelone.validation.minArea",
+				args: {
+					min,
+					area: Math.round(area)
+				}
+			};
+		}
+	};
 }
 function noSelfIntersection() {
-  return constraint(hasSelfIntersection, () => ({
-    message: "chelone.validation.selfIntersection"
-  }));
+	return constraint(hasSelfIntersection, () => ({ message: "chelone.validation.selfIntersection" }));
 }
-export {
-  countVertices,
-  maxVertices,
-  minAreaM2,
-  minVertices,
-  noSelfIntersection
-};
+export { countVertices, maxVertices, minAreaM2, minVertices, noSelfIntersection };

package/dist/geo/coordinates.js

@@ -1,32 +1,40 @@
 import { isEmpty } from "../form/validators.js";
-const NUMERIC = /^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i;
+// src/geo/coordinates.ts
+var NUMERIC = /^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i;
+/** A finite number from a number or a numeric string, else `null`. `0` is valid. */
 function toCoordinate(value) {
-  if (typeof value === "number") return Number.isFinite(value) ? value : null;
-  if (typeof value !== "string") return null;
-  const text = value.trim();
-  if (!NUMERIC.test(text)) return null;
-  const parsed = Number(text);
-  return Number.isFinite(parsed) ? parsed : null;
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value !== "string") return null;
+	const text = value.trim();
+	if (!NUMERIC.test(text)) return null;
+	const parsed = Number(text);
+	return Number.isFinite(parsed) ? parsed : null;
 }
 function rangeValidator(min, max, message) {
-  return (value, values) => {
-    if (isEmpty(value)) return void 0;
-    const coordinate = toCoordinate(value);
-    if (coordinate !== null && coordinate >= min && coordinate <= max) {
-      return void 0;
-    }
-    const args = { min, max };
-    return typeof message === "function" ? message({ args, value, values }) : { message, args };
-  };
+	return (value, values) => {
+		if (isEmpty(value)) return void 0;
+		const coordinate = toCoordinate(value);
+		if (coordinate !== null && coordinate >= min && coordinate <= max) return;
+		const args = {
+			min,
+			max
+		};
+		return typeof message === "function" ? message({
+			args,
+			value,
+			values
+		}) : {
+			message,
+			args
+		};
+	};
 }
+/** Errors outside -90..90 (or on a non-number). Skips empty values. */
 function latitude(message = "chelone.validation.latitude") {
-  return rangeValidator(-90, 90, message);
+	return rangeValidator(-90, 90, message);
 }
+/** Errors outside -180..180 (or on a non-number). Skips empty values. */
 function longitude(message = "chelone.validation.longitude") {
-  return rangeValidator(-180, 180, message);
+	return rangeValidator(-180, 180, message);
 }
-export {
-  latitude,
-  longitude,
-  toCoordinate
-};
+export { latitude, longitude, toCoordinate };

package/dist/geo/editor.d.ts

@@ -1,5 +1,11 @@
-import type { GeoFeature } from "./geojson.js";
+import type { Feature, Geometry, LineString, Point, Polygon } from "geojson";
+import { type JsonObject } from "../guards.js";
 import type { ShapeStyle } from "./map-layers.js";
+type EditorGeometry = Point | LineString | Polygon;
+/** A feature as the editor takes it: a drawable geometry, JSON properties and an id. */
+export type EditorFeature = Feature<EditorGeometry, JsonObject> & {
+    id: string | number;
+};
 export declare const EDITOR_PROPERTIES: {
     readonly mode: "mode";
     readonly currentlyDrawing: "currentlyDrawing";
@@ -28,25 +34,19 @@ export declare const EDITOR_PROPERTIES: {
  * decimals, cut to longitude and latitude, and wrapped. The source is not
  * rewritten.
  */
-export declare function toEditorFeatures(features: GeoFeature[], getId: () => string | number): GeoFeature[];
+export declare function toEditorFeatures(features: Feature<Geometry | null, JsonObject | null>[], getId: () => string | number): EditorFeature[];
 /** What `getSnapshot()` of the editor returns, as far as core reads it. */
-export interface EditorSnapshotFeature {
-    type?: "Feature";
-    id?: string | number;
-    geometry: {
-        type: string;
-        coordinates?: unknown;
-    } | null;
-    properties: object | null;
-}
+export type EditorSnapshotFeature = Feature<EditorGeometry, JsonObject>;
 /**
  * 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.
+ * 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.
  */
-export declare function fromEditorFeatures(snapshot: readonly EditorSnapshotFeature[]): GeoFeature[];
+export declare function fromEditorFeatures(snapshot: readonly EditorSnapshotFeature[]): Feature<Geometry | null, JsonObject | null>[];
 type EditorModeStyle = Record<string, string | number>;
 /** The `styles` option of each drawing mode, by mode name. */
 export type EditorStyles = Record<"point" | "linestring" | "polygon" | "rectangle" | "circle" | "render" | "select", EditorModeStyle>;