@chelone/vue 0.0.0-stage → 0.1.0

package/dist/components/maps-osm/osm-feature-operator.vue.d.ts

@@ -0,0 +1,33 @@
+import type { OsmPresetName, OsmTagInput, OverpassProvider } from "@chelone/core";
+/** Props for {@link OsmFeatureOperator}. */
+export interface OsmFeatureOperatorProps {
+    /** The form field holding the Polygon or MultiPolygon. */
+    source: string;
+    /** `subtract` removes the matching OSM areas from the polygon; `add` merges them in. */
+    mode: "subtract" | "add";
+    /** Named OSM feature sets to query, such as `water`. */
+    presets?: readonly OsmPresetName[];
+    /** Extra Overpass tag filters, such as `natural=wood`. */
+    tags?: readonly OsmTagInput[];
+    /** The button text, translated. Defaults to the mode's message. */
+    label?: string;
+    /** Defaults to the `overpass` of `MapsProvider`. One of the two is required. */
+    provider?: OverpassProvider;
+    disabled?: boolean;
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<OsmFeatureOperatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<OsmFeatureOperatorProps> & Readonly<{}>, {
+    label: string;
+    disabled: boolean;
+    provider: OverpassProvider;
+    presets: readonly OsmPresetName[];
+    tags: readonly OsmTagInput[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    icon?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/maps-osm/osm-feature-operator.vue.js

@@ -0,0 +1,150 @@
+import { defineComponent, ref, onBeforeUnmount, openBlock, createBlock, normalizeClass, withCtx, renderSlot, createTextVNode, toDisplayString, unref, toRaw } from "vue";
+import { geoBounds, areaInTypeOf, geoAreaM2, OverpassRateLimitError } from "@chelone/core";
+import { useQueryClient } from "@tanstack/vue-query";
+import { useInput } from "../../form/use-input.js";
+import { useTranslate } from "../../i18n/use-translate.js";
+import { useNotify } from "../../notification-hooks.js";
+import { useMapsConfig } from "../maps/use-map.js";
+import _sfc_main$1 from "../ui/button.vue.js";
+import _sfc_main$2 from "../ui/spinner2.vue.js";
+import { fetchOsmFeatures } from "./osm-features.js";
+import { subtractMask, unionAll } from "./osm-geometry-ops.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "osm-feature-operator",
+  props: {
+    source: {},
+    mode: {},
+    presets: { default: void 0 },
+    tags: { default: void 0 },
+    label: { default: void 0 },
+    provider: { default: void 0 },
+    disabled: { type: Boolean, default: false },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const isArea = (value) => {
+      const type = value?.type;
+      return type === "Polygon" || type === "MultiPolygon";
+    };
+    const isAbort = (error) => error?.name === "AbortError";
+    const km2 = (m2) => `${(Math.max(0, m2) / 1e6).toFixed(3)} km²`;
+    const config = useMapsConfig();
+    if (!(props.provider ?? config.overpass)) {
+      throw new Error(
+        "OsmFeatureOperator needs an Overpass provider: pass the `provider` prop or set `overpass` on <MapsProvider>."
+      );
+    }
+    const translate = useTranslate();
+    const notify = useNotify();
+    const queryClient = useQueryClient();
+    const input = useInput({ source: props.source, format: (v) => v ?? null });
+    const running = ref(false);
+    let controller = null;
+    onBeforeUnmount(() => controller?.abort());
+    function write(geometry) {
+      input.setValue(geometry);
+      input.blur();
+    }
+    async function run() {
+      const provider = props.provider ?? config.overpass;
+      if (!provider) return;
+      const value = toRaw(input.value.value);
+      if ((props.presets?.length ?? 0) + (props.tags?.length ?? 0) === 0) {
+        notify("chelone.map.osm.no_sources", { type: "warning" });
+        return;
+      }
+      if (!isArea(value)) {
+        notify("chelone.map.osm.no_polygon", { type: "warning" });
+        return;
+      }
+      const abort = new AbortController();
+      controller = abort;
+      running.value = true;
+      try {
+        const found = await fetchOsmFeatures(
+          queryClient,
+          geoBounds(value),
+          { presets: props.presets, tags: props.tags },
+          { provider, signal: abort.signal }
+        );
+        if (abort.signal.aborted) return;
+        if (toRaw(input.value.value) !== value) return;
+        const matches = found?.features ?? [];
+        if (matches.length === 0) {
+          notify("chelone.map.osm.no_match", { type: "info" });
+          return;
+        }
+        if (props.mode === "subtract") {
+          const left = subtractMask(value, matches);
+          if (left === null) {
+            write(null);
+            notify("chelone.map.osm.covered", { type: "warning" });
+            return;
+          }
+          const kept2 = areaInTypeOf(value, left);
+          if (!kept2) {
+            notify("chelone.map.osm.would_split", { type: "warning" });
+            return;
+          }
+          write(kept2);
+          notify("chelone.map.osm.subtracted", {
+            type: "success",
+            messageArgs: { area: km2(geoAreaM2(value) - geoAreaM2(kept2)) }
+          });
+          return;
+        }
+        const merged = unionAll([
+          { type: "Feature", properties: {}, geometry: value },
+          ...matches
+        ]);
+        if (merged === null) {
+          notify("chelone.map.osm.union_empty", { type: "warning" });
+          return;
+        }
+        const kept = areaInTypeOf(value, merged);
+        if (!kept) {
+          notify("chelone.map.osm.would_split", { type: "warning" });
+          return;
+        }
+        write(kept);
+        notify("chelone.map.osm.added", {
+          type: "success",
+          messageArgs: { area: km2(geoAreaM2(kept) - geoAreaM2(value)) }
+        });
+      } catch (error) {
+        if (abort.signal.aborted || isAbort(error)) return;
+        notify(
+          error instanceof OverpassRateLimitError ? "chelone.map.osm.rate_limited" : "chelone.map.osm.error",
+          { type: "error" }
+        );
+      } finally {
+        if (controller === abort) {
+          controller = null;
+          if (!abort.signal.aborted) running.value = false;
+        }
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        type: "button",
+        variant: "outline",
+        "data-slot": "osm-feature-operator",
+        class: normalizeClass(props.class),
+        disabled: props.disabled || running.value,
+        onClick: run
+      }, {
+        default: withCtx(() => [
+          running.value ? (openBlock(), createBlock(_sfc_main$2, { key: 0 })) : renderSlot(_ctx.$slots, "icon", { key: 1 }),
+          createTextVNode(" " + toDisplayString(unref(translate)(
+            props.label ?? (props.mode === "subtract" ? "chelone.map.osm.subtract" : "chelone.map.osm.add")
+          )), 1)
+        ]),
+        _: 3
+      }, 8, ["class", "disabled"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps-osm/osm-feature-operator2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./osm-feature-operator.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/maps-osm/osm-feature-operators.d.ts

@@ -0,0 +1,19 @@
+import { type OsmFeatureOperatorProps } from "./osm-feature-operator.vue.js";
+export type OsmFeatureSubtractProps = Omit<OsmFeatureOperatorProps, "mode">;
+export type OsmFeatureAddProps = Omit<OsmFeatureOperatorProps, "mode">;
+/**
+ * Removes OpenStreetMap areas, such as water, from the polygon in a form field.
+ * The `icon` slot replaces the default icon.
+ *
+ * @example
+ * <OsmFeatureSubtract source="area" :presets="['water']" />
+ */
+export declare const OsmFeatureSubtract: import("vue").DefineSetupFnComponent<Omit<OsmFeatureOperatorProps, "mode">, {}, {}, Omit<OsmFeatureOperatorProps, "mode"> & {}, import("vue").PublicProps>;
+/**
+ * Merges OpenStreetMap areas, such as buildings, into the polygon in a form field.
+ * The `icon` slot replaces the default icon.
+ *
+ * @example
+ * <OsmFeatureAdd source="area" :presets="['buildings']" />
+ */
+export declare const OsmFeatureAdd: import("vue").DefineSetupFnComponent<Omit<OsmFeatureOperatorProps, "mode">, {}, {}, Omit<OsmFeatureOperatorProps, "mode"> & {}, import("vue").PublicProps>;

package/dist/components/maps-osm/osm-feature-operators.js

@@ -0,0 +1,42 @@
+import { defineComponent, h } from "vue";
+import _sfc_main from "./osm-feature-operator.vue.js";
+const { mode: _mode, ...options } = _sfc_main.props;
+const svg = (...paths) => h(
+  "svg",
+  {
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": 2,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round",
+    "aria-hidden": "true",
+    class: "size-4"
+  },
+  paths.map((d) => h("path", { d }))
+);
+const subtractIcon = () => svg(
+  "m7 21-4.3-4.3a1 1 0 0 1 0-1.4l9.6-9.6a1 1 0 0 1 1.4 0l5.6 5.6a1 1 0 0 1 0 1.4L13 21",
+  "M22 21H7",
+  "m5 11 9 9"
+);
+const addIcon = () => svg("M5 12h14", "M12 5v14");
+function operator(name, mode, icon) {
+  return defineComponent(
+    (props, { slots }) => () => h(_sfc_main, { ...props, mode }, { icon: slots.icon ?? icon }),
+    {
+      name,
+      props: options
+    }
+  );
+}
+const OsmFeatureSubtract = operator(
+  "OsmFeatureSubtract",
+  "subtract",
+  subtractIcon
+);
+const OsmFeatureAdd = operator("OsmFeatureAdd", "add", addIcon);
+export {
+  OsmFeatureAdd,
+  OsmFeatureSubtract
+};

package/dist/components/maps-osm/osm-features.d.ts

@@ -0,0 +1,22 @@
+import { type GeoBBox, type GeoFeatureCollection, type OsmPresetName, type OverpassProvider, type OverpassQuerySources } from "@chelone/core";
+import type { QueryClient } from "@tanstack/vue-query";
+/**
+ * Turns an Overpass JSON answer (from `out geom`) into Polygon and
+ * MultiPolygon features. Polygons pass through. A line is buffered only when
+ * `presets` names a preset with `bufferLinesMeters` that accepts its tags; any
+ * other line and every point is dropped.
+ */
+export declare function osmToPolygons(response: unknown, presets: readonly OsmPresetName[]): GeoFeatureCollection;
+export interface FetchOsmFeaturesOptions {
+    provider: OverpassProvider;
+    /** Stops this call waiting; a request shared with another caller goes on. */
+    signal?: AbortSignal;
+}
+/** True when `sources` names at least one preset or tag. */
+export declare function hasOsmSources(sources: OverpassQuerySources): boolean;
+/**
+ * Queries Overpass for the features in `bbox` and converts them to polygons.
+ * The answer goes through `queryClient`, so the same query is cached. Resolves
+ * to `null`, without a request, for a null `bbox` or no presets and tags.
+ */
+export declare function fetchOsmFeatures(queryClient: QueryClient, bbox: GeoBBox | null, sources: OverpassQuerySources, { provider, signal }: FetchOsmFeaturesOptions): Promise<GeoFeatureCollection | null>;

package/dist/components/maps-osm/osm-features.js

@@ -0,0 +1,67 @@
+import { buildOverpassQuery, overpassQueryOptions, OSM_PRESETS, findPresetForTags } from "@chelone/core";
+import { buffer } from "@turf/buffer";
+import osm2geojson from "osm2geojson-lite";
+function isPolygon(feature) {
+  const type = feature.geometry?.type;
+  return type === "Polygon" || type === "MultiPolygon";
+}
+function osmToPolygons(response, presets) {
+  const converted = osm2geojson(response, {
+    completeFeature: true,
+    renderTagged: true
+  });
+  const bufferingPresets = presets.filter((name) => {
+    const preset = OSM_PRESETS[name];
+    return preset.bufferLinesMeters !== void 0;
+  });
+  const features = [];
+  for (const feature of converted.features) {
+    const type = feature.geometry?.type;
+    if (isPolygon(feature)) {
+      features.push(feature);
+    } else if (type === "LineString" || type === "MultiLineString") {
+      const meters = findPresetForTags(
+        feature.properties ?? {},
+        bufferingPresets
+      )?.bufferLinesMeters;
+      if (!meters) continue;
+      const buffered = buffer(feature, meters, {
+        units: "meters"
+      });
+      const geometry = buffered?.geometry;
+      if (geometry?.type === "Polygon" || geometry?.type === "MultiPolygon") {
+        features.push({
+          type: "Feature",
+          properties: feature.properties,
+          geometry
+        });
+      }
+    }
+  }
+  return { type: "FeatureCollection", features };
+}
+function hasOsmSources(sources) {
+  return (sources.presets?.length ?? 0) + (sources.tags?.length ?? 0) > 0;
+}
+async function fetchOsmFeatures(queryClient, bbox, sources, { provider, signal }) {
+  if (!bbox || !hasOsmSources(sources)) return null;
+  const query = buildOverpassQuery(sources, bbox);
+  signal?.throwIfAborted();
+  const fetching = queryClient.fetchQuery(
+    overpassQueryOptions(provider, query)
+  );
+  const answer = await (signal ? abortable(fetching, signal) : fetching);
+  return osmToPolygons(answer, sources.presets ?? []);
+}
+function abortable(promise, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+export {
+  fetchOsmFeatures,
+  hasOsmSources,
+  osmToPolygons
+};

package/dist/components/maps-osm/osm-geometry-ops.d.ts

@@ -0,0 +1,16 @@
+import { type GeoFeature, type GeoGeometry } from "@chelone/core";
+type Area = Extract<GeoGeometry, {
+    type: "Polygon" | "MultiPolygon";
+}>;
+/**
+ * The union of the Polygon and MultiPolygon features as one geometry; other
+ * geometries are ignored. `null` when there is none. One feature comes back
+ * as its own geometry, without a turf call.
+ */
+export declare function unionAll(features: readonly GeoFeature[]): Area | null;
+/**
+ * `input` minus every polygon in `mask`. An empty mask, or one that does not
+ * reach `input`, returns `input` itself; `null` when nothing of it is left.
+ */
+export declare function subtractMask(input: Area, mask: readonly GeoFeature[]): Area | null;
+export {};

package/dist/components/maps-osm/osm-geometry-ops.js

@@ -0,0 +1,41 @@
+import { geoAreaM2, geoBounds } from "@chelone/core";
+import { difference } from "@turf/difference";
+import { union } from "@turf/union";
+function isArea(geometry) {
+  return geometry?.type === "Polygon" || geometry?.type === "MultiPolygon";
+}
+const asFeature = (geometry) => ({ type: "Feature", properties: {}, geometry });
+function unionAll(features) {
+  const areas = features.map((f) => f.geometry).filter(isArea);
+  const [first, ...rest] = areas;
+  if (!first) return null;
+  if (rest.length === 0) return first;
+  const merged = union({
+    type: "FeatureCollection",
+    features: areas.map(asFeature)
+  });
+  return isArea(merged?.geometry) ? merged?.geometry : null;
+}
+function subtractMask(input, mask) {
+  const masked = unionAll(mask);
+  if (!masked) return input;
+  if (!boxesOverlap(input, masked)) return input;
+  const left = difference({
+    type: "FeatureCollection",
+    features: [asFeature(input), asFeature(masked)]
+  });
+  const geometry = left?.geometry;
+  if (!isArea(geometry) || geoAreaM2(geometry) <= 0) return null;
+  return geometry;
+}
+function boxesOverlap(a, b) {
+  const boxA = geoBounds(a);
+  const boxB = geoBounds(b);
+  if (!boxA || !boxB) return true;
+  if (boxA[0] > boxA[2] || boxB[0] > boxB[2]) return true;
+  return boxA[0] <= boxB[2] && boxB[0] <= boxA[2] && boxA[1] <= boxB[3] && boxB[1] <= boxA[3];
+}
+export {
+  subtractMask,
+  unionAll
+};

package/dist/components/maps-osm/reverse-geocode-field.vue.d.ts

@@ -0,0 +1,21 @@
+import type { GeocodingProvider } from "@chelone/core";
+/** Props for {@link ReverseGeocodeField}. */
+export interface ReverseGeocodeFieldProps {
+    /** The record property holding the latitude. */
+    latSource: string;
+    /** The record property holding the longitude. */
+    lngSource: string;
+    /** Defaults to the ambient record. */
+    record?: Record<string, unknown>;
+    /** `full` is the whole name, `street` its first part and `city` its first two. Defaults to `full`. */
+    format?: "full" | "street" | "city";
+    /** Defaults to the `geocoder` of `MapsProvider`. One of the two is required. */
+    provider?: GeocodingProvider;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<ReverseGeocodeFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ReverseGeocodeFieldProps> & Readonly<{}>, {
+    record: Record<string, unknown>;
+    format: "full" | "street" | "city";
+    provider: GeocodingProvider;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/maps-osm/reverse-geocode-field.vue.js

@@ -0,0 +1,63 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, unref, createBlock, Fragment, createTextVNode, toDisplayString, createCommentVNode } from "vue";
+import { toCoordinate } from "@chelone/core";
+import { cn } from "../../lib/utils.js";
+import { useFieldValue } from "../../record/use-field-value.js";
+import _sfc_main$1 from "../ui/skeleton.vue.js";
+import { useReverseGeocode } from "./use-reverse-geocode.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "reverse-geocode-field",
+  props: {
+    latSource: {},
+    lngSource: {},
+    record: { default: void 0 },
+    format: { default: "full" },
+    provider: { default: void 0 },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const latValue = useFieldValue({
+      source: props.latSource,
+      record: props.record
+    });
+    const lngValue = useFieldValue({
+      source: props.lngSource,
+      record: props.record
+    });
+    const lat = computed(() => toCoordinate(latValue.value));
+    const lng = computed(() => toCoordinate(lngValue.value));
+    const found = useReverseGeocode(
+      () => ({
+        lat: lat.value ?? Number.NaN,
+        lng: lng.value ?? Number.NaN
+      }),
+      { provider: props.provider }
+    );
+    const text = computed(() => {
+      const name = found.data.value?.displayName;
+      if (name === void 0) {
+        return `${lat.value?.toFixed(4)}, ${lng.value?.toFixed(4)}`;
+      }
+      if (props.format === "full") return name;
+      const parts = name.split(",").map((part) => part.trim());
+      return parts.slice(0, props.format === "street" ? 1 : 2).join(", ");
+    });
+    return (_ctx, _cache) => {
+      return lat.value !== null && lng.value !== null ? (openBlock(), createElementBlock("span", {
+        key: 0,
+        "data-slot": "reverse-geocode-field",
+        class: normalizeClass(unref(cn)("text-sm", props.class))
+      }, [
+        unref(found).isPending.value ? (openBlock(), createBlock(_sfc_main$1, {
+          key: 0,
+          class: "inline-block h-4 w-40 align-middle"
+        })) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+          createTextVNode(toDisplayString(text.value), 1)
+        ], 64))
+      ], 2)) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps-osm/reverse-geocode-field2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./reverse-geocode-field.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/maps-osm/use-geocode.d.ts

@@ -0,0 +1,29 @@
+import { type GeoBBox, type GeocodeResult, type GeocodingProvider } from "@chelone/core";
+import { type MaybeRefOrGetter } from "vue";
+export interface UseGeocodeOptions {
+    /** Defaults to the `geocoder` of `MapsProvider`. One of the two is required. */
+    provider?: GeocodingProvider;
+    /** Shortest trimmed query that searches. Defaults to 3. */
+    minChars?: number;
+    /** Wait this long after the last change of `query` before searching. Defaults to 0. */
+    debounceMs?: number;
+    /** `false` stops the search whatever the query. */
+    enabled?: boolean;
+    /** 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;
+    limit?: number;
+}
+/**
+ * Searches `query` with a geocoding provider. Nothing runs until the trimmed
+ * query reaches `minChars`. The query's abort signal reaches the provider, so a
+ * newer query cancels the older request.
+ *
+ * Needs a provider, from the `provider` option or `MapsProvider`'s `geocoder`;
+ * with neither it throws.
+ *
+ * @example
+ * const { data, isFetching } = useGeocode(text, { provider, debounceMs: 300 });
+ */
+export declare function useGeocode(query: MaybeRefOrGetter<string>, options?: MaybeRefOrGetter<UseGeocodeOptions>): import("@tanstack/vue-query").UseQueryReturnType<GeocodeResult[], Error>;

package/dist/components/maps-osm/use-geocode.js

@@ -0,0 +1,46 @@
+import { geocodeQueryOptions } from "@chelone/core";
+import { useQuery } from "@tanstack/vue-query";
+import { computed, toValue, ref, watch, onScopeDispose } from "vue";
+import { useMapsConfig } from "../maps/use-map.js";
+function useDebounced(source, delayMs) {
+  const settled = ref(source());
+  let timer;
+  watch([source, delayMs], ([value, delay]) => {
+    clearTimeout(timer);
+    if (delay <= 0) return;
+    timer = setTimeout(() => {
+      settled.value = value;
+    }, delay);
+  });
+  onScopeDispose(() => clearTimeout(timer));
+  return () => delayMs() <= 0 ? source() : settled.value;
+}
+function useGeocode(query, options = {}) {
+  const config = useMapsConfig();
+  const resolve = () => toValue(options).provider ?? config.geocoder;
+  if (!resolve()) {
+    throw new Error(
+      "useGeocode needs a geocoding provider: pass the `provider` option or set `geocoder` on <MapsProvider>."
+    );
+  }
+  const settled = useDebounced(
+    () => toValue(query),
+    () => toValue(options).debounceMs ?? 0
+  );
+  const request = computed(() => {
+    const { minChars, countryCodes, viewBox, limit, enabled } = toValue(options);
+    const provider = resolve();
+    if (!provider) throw new Error("useGeocode lost its geocoding provider.");
+    const base = geocodeQueryOptions(provider, settled(), {
+      minChars,
+      countryCodes,
+      viewBox,
+      limit
+    });
+    return { ...base, enabled: (enabled ?? true) && base.enabled };
+  });
+  return useQuery(request);
+}
+export {
+  useGeocode
+};

package/dist/components/maps-osm/use-osm-features.d.ts

@@ -0,0 +1,22 @@
+import { type GeoBBox, type GeoFeatureCollection, type OverpassProvider, type OverpassQuerySources } from "@chelone/core";
+import { type MaybeRefOrGetter } from "vue";
+export interface UseOsmFeaturesOptions {
+    /** Defaults to the `overpass` of `MapsProvider`. One of the two is required. */
+    provider?: OverpassProvider;
+    /** `false` stops the query whatever the box. */
+    enabled?: boolean;
+    /** Defaults to 1 hour. */
+    staleTime?: number;
+}
+/**
+ * The polygons of the OpenStreetMap features in `bbox`: an Overpass query, its
+ * answer converted by `osmToPolygons`. Idle while `bbox` is null or `sources`
+ * names no preset and no tag. `bbox` and `sources` may be refs or getters.
+ *
+ * Needs a provider, from the `provider` option or `MapsProvider`'s `overpass`;
+ * with neither it throws.
+ *
+ * @example
+ * const { data } = useOsmFeatures(bbox, { presets: ["water"] }, { provider });
+ */
+export declare function useOsmFeatures(bbox: MaybeRefOrGetter<GeoBBox | null>, sources: MaybeRefOrGetter<OverpassQuerySources>, options?: UseOsmFeaturesOptions): import("@tanstack/vue-query").UseQueryReturnType<GeoFeatureCollection, Error>;

package/dist/components/maps-osm/use-osm-features.js

@@ -0,0 +1,37 @@
+import { overpassQueryOptions, buildOverpassQuery } from "@chelone/core";
+import { useQuery } from "@tanstack/vue-query";
+import { computed, toValue } from "vue";
+import { useMapsConfig } from "../maps/use-map.js";
+import { hasOsmSources, osmToPolygons } from "./osm-features.js";
+function useOsmFeatures(bbox, sources, options = {}) {
+  const config = useMapsConfig();
+  const resolve = () => options.provider ?? config.overpass;
+  if (!resolve()) {
+    throw new Error(
+      "useOsmFeatures needs an Overpass provider: pass the `provider` option or set `overpass` on <MapsProvider>."
+    );
+  }
+  const request = computed(() => {
+    const provider = resolve();
+    if (!provider)
+      throw new Error("useOsmFeatures lost its Overpass provider.");
+    const box = toValue(bbox);
+    const wanted = toValue(sources);
+    const active = box !== null && hasOsmSources(wanted);
+    const base = overpassQueryOptions(
+      provider,
+      active ? buildOverpassQuery(wanted, box) : "",
+      { staleTime: options.staleTime }
+    );
+    const presets = wanted.presets ?? [];
+    return {
+      ...base,
+      enabled: (options.enabled ?? true) && active && base.enabled,
+      select: (answer) => osmToPolygons(answer, presets)
+    };
+  });
+  return useQuery(request);
+}
+export {
+  useOsmFeatures
+};

package/dist/components/maps-osm/use-reverse-geocode.d.ts

@@ -0,0 +1,24 @@
+import { type GeocodeResult, type GeocodingProvider } from "@chelone/core";
+import { type MaybeRefOrGetter } from "vue";
+export interface UseReverseGeocodeOptions {
+    /** Defaults to the `geocoder` of `MapsProvider`. One of the two is required. */
+    provider?: GeocodingProvider;
+    /** `false` stops the lookup whatever the position. */
+    enabled?: boolean;
+}
+/**
+ * Names a position with a geocoding provider. Nothing runs until `lat` and
+ * `lng` are both finite numbers. The result is `null` when the provider knows
+ * no place there. The query's abort signal reaches the provider. `position` may
+ * be a ref or a getter.
+ *
+ * Needs a provider, from the `provider` option or `MapsProvider`'s `geocoder`;
+ * with neither it throws.
+ *
+ * @example
+ * const { data } = useReverseGeocode(() => ({ lat: lat.value, lng: lng.value }), { provider });
+ */
+export declare function useReverseGeocode(position: MaybeRefOrGetter<{
+    lat: number;
+    lng: number;
+}>, options?: UseReverseGeocodeOptions): import("@tanstack/vue-query").UseQueryReturnType<GeocodeResult | null, Error>;