@chelone/vue 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,70 @@
+import { geoAreaM2 } from "@chelone/core";
+import { difference } from "@turf/difference";
+import { simplify } from "@turf/simplify";
+function isArea(geometry) {
+  return geometry?.type === "Polygon" || geometry?.type === "MultiPolygon";
+}
+function sameArea(a, b) {
+  return Math.abs(a - b) <= Math.max(a, b) * 1e-9;
+}
+function cutFeatures(features, cutter) {
+  const out = [];
+  let changed = false;
+  const cutGeometry = cutter.geometry;
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    if (!isArea(geometry) || !isArea(cutGeometry)) {
+      out.push(feature);
+      continue;
+    }
+    const left = difference({
+      type: "FeatureCollection",
+      features: [
+        { type: "Feature", properties: {}, geometry },
+        { type: "Feature", properties: {}, geometry: cutGeometry }
+      ]
+    });
+    if (!left) {
+      changed = true;
+      continue;
+    }
+    const rest = left.geometry;
+    if (sameArea(geoAreaM2(rest), geoAreaM2(geometry))) {
+      out.push(feature);
+      continue;
+    }
+    changed = true;
+    const parts = rest.type === "Polygon" ? [rest] : rest.coordinates.map((coordinates) => ({
+      type: "Polygon",
+      coordinates
+    }));
+    parts.forEach((part, index) => {
+      const { id: _id, ...rest2 } = feature;
+      out.push({ ...index === 0 ? feature : rest2, geometry: part });
+    });
+  }
+  return { features: out, changed };
+}
+function simplifyInPlace(value, options) {
+  if (value.type === "FeatureCollection") {
+    value.features = value.features.map(
+      (feature) => simplifyInPlace(feature, options)
+    );
+    return value;
+  }
+  if (value.type === "Feature" && !value.geometry) return value;
+  return simplify(value, {
+    tolerance: options.tolerance,
+    highQuality: options.highQuality,
+    mutate: true
+  });
+}
+function simplifyGeo(value, options) {
+  const copy = structuredClone(value);
+  if (options.tolerance <= 0) return copy;
+  return simplifyInPlace(copy, options);
+}
+export {
+  cutFeatures,
+  simplifyGeo
+};

package/dist/components/maps-draw/shape-input.vue.d.ts

@@ -0,0 +1,87 @@
+import { type MapStyleInput, type ShapeStyle, type ShapeValue, type ShapeValueKind, type Validator } from "@chelone/core";
+import { type DrawTool } from "./use-terra-draw.js";
+type ToolbarTool = DrawTool | "delete";
+/** Props for {@link ShapeInput}. */
+export interface ShapeInputProps {
+    /** The form field holding the GeoJSON value. */
+    source: string;
+    /** The kind of value the field holds, which decides what a drawing writes. */
+    kind: ShapeValueKind;
+    /** The legend. A string is translated; `false` renders none. */
+    label?: string | false;
+    helperText?: string | false;
+    /** Runs after the limits below. Read once. */
+    validate?: Validator | readonly Validator[];
+    /** Fewest vertices the shape may have; a polygon ring counts its distinct vertices. The shape is stored as drawn and the field is flagged. Read once. */
+    minVertices?: number;
+    /** Most vertices the shape may have. Read once. */
+    maxVertices?: number;
+    /** Smallest area in square metres a polygon may cover. Read once. */
+    minAreaM2?: number;
+    /** Set to false to flag a shape that crosses itself. Defaults to true, which checks nothing. Read once. */
+    allowSelfIntersection?: boolean;
+    /** The toolbar buttons, in order. Defaults to the tools that suit `kind`. */
+    tools?: readonly ToolbarTool[];
+    /** Snap to existing coordinates and lines. Read once. Defaults to true. */
+    snappable?: boolean;
+    /** Pixels within which the pointer grabs a vertex or snaps. Read once. Defaults to 20. */
+    snapDistance?: number;
+    /** Shows the shape and hides the toolbar; pan and zoom still work. */
+    disabled?: boolean;
+    /** `[lat, lng]`. The map centre while the field is empty. Defaults to `[0, 0]`. */
+    defaultCenter?: readonly [lat: number, lng: number];
+    /** Read once at mount. Defaults to 13. */
+    zoom?: number;
+    /** In pixels, or any CSS length. Defaults to 300. */
+    height?: number | string;
+    /** Defaults to the style from `MapsProvider`. */
+    mapStyle?: MapStyleInput;
+    /** Partial over `DEFAULT_SHAPE_STYLE`. Read once. */
+    shapeStyle?: ShapeStyle;
+    /**
+     * Width over height of a `BBox` value. The stored box grows around its centre
+     * to this ratio and never shrinks, and the rectangle on the map follows it.
+     */
+    aspectRatio?: number;
+    /** Frame the first value on the map. The user's own edits never refit. Defaults to true. */
+    fitBounds?: boolean;
+    /**
+     * Adjusts the value after the user's own drawing or edit, such as snapping a
+     * line to roads. It runs once the edit is in the form, never on load or
+     * reset, and a newer edit or an unmount aborts `signal`. A result that is
+     * not null and differs is written, unless the field changed meanwhile. A
+     * thrown error keeps the value as drawn.
+     */
+    refine?: (value: ShapeValue, options: {
+        signal: AbortSignal;
+    }) => Promise<ShapeValue | null> | ShapeValue | null;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<ShapeInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    commit: (value: ShapeValue | null) => any;
+}, string, import("vue").PublicProps, Readonly<ShapeInputProps> & Readonly<{
+    onCommit?: ((value: ShapeValue | null) => any) | undefined;
+}>, {
+    label: string | false;
+    disabled: boolean;
+    height: number | string;
+    validate: Validator | readonly Validator[];
+    helperText: string | false;
+    mapStyle: MapStyleInput;
+    zoom: number;
+    tools: readonly ToolbarTool[];
+    snappable: boolean;
+    snapDistance: number;
+    shapeStyle: ShapeStyle;
+    minVertices: number;
+    maxVertices: number;
+    minAreaM2: number;
+    allowSelfIntersection: boolean;
+    defaultCenter: readonly [lat: number, lng: number];
+    aspectRatio: number;
+    fitBounds: boolean;
+    refine: (value: ShapeValue, options: {
+        signal: AbortSignal;
+    }) => Promise<ShapeValue | null> | ShapeValue | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/maps-draw/shape-input.vue.js

@@ -0,0 +1,305 @@
+import { defineComponent, computed, ref, shallowRef, onBeforeUnmount, openBlock, createElementBlock, normalizeClass, unref, createVNode, createCommentVNode, createBlock, withCtx, toDisplayString, toRaw, watch } from "vue";
+import { minVertices, maxVertices, minAreaM2, noSelfIntersection, shapeToFeatures, heldFeatures, featuresToShape, geoBounds, isLngLatBox } from "@chelone/core";
+import { useInput } from "../../form/use-input.js";
+import { useTranslate } from "../../i18n/use-translate.js";
+import { cn } from "../../lib/utils.js";
+import _sfc_main$4 from "../admin/common/input-helper-text.vue.js";
+import _sfc_main$5 from "../admin/common/validation-error.vue.js";
+import _sfc_main$1 from "../admin/common/field-label-text.vue.js";
+import _sfc_main$3 from "../maps/map-canvas.vue.js";
+import { FieldError } from "../ui/field.js";
+import _sfc_main$2 from "./draw-toolbar.vue.js";
+import { cutFeatures } from "./geometry-ops.js";
+import { useGeoJsonSource, uniqueGeoJsonSourceId } from "../maps/use-geo-json-source.js";
+import { useMap } from "../maps/use-map.js";
+import { useTerraDraw } from "./use-terra-draw.js";
+const _hoisted_1 = ["data-invalid"];
+const _hoisted_2 = {
+  key: 0,
+  class: "mb-1.5 text-sm font-medium"
+};
+const _hoisted_3 = { key: 0 };
+const _hoisted_4 = {
+  key: 2,
+  "data-slot": "shape-input-warning",
+  class: "text-sm text-amber-600 dark:text-amber-500"
+};
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) return false;
+  return keysA.every(
+    (key) => sameValue(
+      a[key],
+      b[key]
+    )
+  );
+}
+const AREA_TOOLS = [
+  "draw-polygon",
+  "draw-rectangle",
+  "draw-circle",
+  "cut",
+  "edit",
+  "move",
+  "delete"
+];
+const HOLDS_MANY = /* @__PURE__ */ new Set([
+  "MultiPoint",
+  "MultiLineString",
+  "MultiPolygon",
+  "GeometryCollection",
+  "FeatureCollection"
+]);
+function defaultTools(kind) {
+  switch (kind) {
+    case "Point":
+    case "MultiPoint":
+      return ["draw-point", "move", "delete"];
+    case "LineString":
+    case "MultiLineString":
+      return ["draw-line", "edit", "move", "delete"];
+    case "Polygon":
+    case "MultiPolygon":
+      return AREA_TOOLS;
+    case "BBox":
+      return ["draw-rectangle", "edit", "move", "delete"];
+    default:
+      return ["draw-point", "draw-line", ...AREA_TOOLS];
+  }
+}
+const Editor = defineComponent({
+  name: "ShapeInputEditor",
+  props: {
+    features: { type: Array, required: true },
+    held: { type: Array, required: true },
+    tool: { type: String, default: null },
+    disabled: { type: Boolean, default: false },
+    snappable: { type: Boolean, default: true },
+    snapDistance: { type: Number, default: 20 },
+    shapeStyle: { type: Object, default: void 0 },
+    fit: { type: Boolean, default: true },
+    /** The field's current value, whatever it holds. */
+    getValue: {
+      type: Function,
+      required: true
+    },
+    written: { type: Object, required: true }
+  },
+  emits: {
+    edit: (_edit) => true,
+    controls: (_controls) => true
+  },
+  setup(props, { emit }) {
+    const map = useMap();
+    useGeoJsonSource(
+      uniqueGeoJsonSourceId(),
+      () => ({
+        type: "FeatureCollection",
+        features: toRaw(props.held)
+      }),
+      () => props.shapeStyle ?? {}
+    );
+    const controls = useTerraDraw({
+      state: () => ({
+        features: props.features,
+        tool: props.tool,
+        disabled: props.disabled
+      }),
+      snappable: props.snappable,
+      snapDistance: props.snapDistance,
+      shapeStyle: props.shapeStyle,
+      onEdit: (edit) => emit("edit", edit)
+    });
+    emit("controls", controls);
+    onBeforeUnmount(() => emit("controls", null));
+    const box = computed(
+      () => geoBounds({
+        type: "FeatureCollection",
+        features: [...toRaw(props.features), ...toRaw(props.held)]
+      })
+    );
+    const boxKey = computed(() => box.value ? box.value.join(",") : "");
+    let fitted = false;
+    watch(
+      boxKey,
+      () => {
+        const corners = box.value;
+        if (!props.fit || fitted || !corners) return;
+        fitted = true;
+        if (props.getValue() === props.written.current) return;
+        if (!isLngLatBox(corners)) return;
+        map.fitBounds(corners, { padding: 20, maxZoom: 18, duration: 0 });
+      },
+      { immediate: true }
+    );
+    return () => null;
+  }
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "shape-input",
+  props: {
+    source: {},
+    kind: {},
+    label: { type: [String, Boolean], default: void 0 },
+    helperText: { type: [String, Boolean], default: void 0 },
+    validate: { type: [Function, Array], default: void 0 },
+    minVertices: { default: void 0 },
+    maxVertices: { default: void 0 },
+    minAreaM2: { default: void 0 },
+    allowSelfIntersection: { type: Boolean, default: true },
+    tools: { default: void 0 },
+    snappable: { type: Boolean, default: true },
+    snapDistance: { default: 20 },
+    disabled: { type: Boolean, default: false },
+    defaultCenter: { default: () => [0, 0] },
+    zoom: { default: 13 },
+    height: { default: 300 },
+    mapStyle: { default: void 0 },
+    shapeStyle: { default: void 0 },
+    aspectRatio: { default: void 0 },
+    fitBounds: { type: Boolean, default: true },
+    refine: { type: Function, default: void 0 },
+    class: {}
+  },
+  emits: ["commit"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const translate = useTranslate();
+    const validators = [
+      ...props.minVertices === void 0 ? [] : [minVertices(props.minVertices)],
+      ...props.maxVertices === void 0 ? [] : [maxVertices(props.maxVertices)],
+      ...props.minAreaM2 === void 0 ? [] : [minAreaM2(props.minAreaM2)],
+      ...props.allowSelfIntersection ? [] : [noSelfIntersection()],
+      ...Array.isArray(props.validate) ? props.validate : props.validate ? [props.validate] : []
+    ];
+    const input = useInput({
+      source: props.source,
+      validate: validators,
+      format: (v) => v ?? null
+    });
+    const draft = computed(() => shapeToFeatures(props.kind, input.value.value));
+    const held = computed(() => heldFeatures(props.kind, input.value.value));
+    const tool = ref(null);
+    const controls = shallowRef(null);
+    const written = { current: void 0 };
+    const invalid = computed(
+      () => input.touched.value && input.error.value != null
+    );
+    let refining = null;
+    onBeforeUnmount(() => refining?.abort());
+    async function runRefine(committed) {
+      const refineValue = props.refine;
+      if (!refineValue) return;
+      const abort = new AbortController();
+      refining = abort;
+      try {
+        const result = await refineValue(committed, { signal: abort.signal });
+        if (abort.signal.aborted || result === null) return;
+        if (toRaw(input.value.value) !== toRaw(committed) || sameValue(result, committed)) {
+          return;
+        }
+        written.current = result;
+        input.setValue(result);
+        input.blur();
+        emit("commit", result);
+      } catch {
+      }
+    }
+    function onEdit(edit) {
+      refining?.abort();
+      const refused = HOLDS_MANY.has(props.kind) ? controls.value?.refused.value ?? [] : [];
+      let features = [...edit.features, ...refused];
+      const prev = input.value.value;
+      let addHeld = true;
+      if (edit.type === "cut") {
+        tool.value = null;
+        const cut = cutFeatures(
+          [...features, ...heldFeatures(props.kind, prev)],
+          edit.cutter
+        );
+        if (!cut.changed) return;
+        if (!HOLDS_MANY.has(props.kind) && cut.features.length > 1) return;
+        features = cut.features;
+        addHeld = false;
+      }
+      const next = featuresToShape(props.kind, features, prev, {
+        aspectRatio: props.aspectRatio,
+        addHeld
+      });
+      written.current = next;
+      input.setValue(next);
+      input.blur();
+      if (edit.type === "draw") tool.value = null;
+      emit("commit", next);
+      if (next !== null) void runRefine(next);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("fieldset", {
+        "data-slot": "shape-input",
+        class: normalizeClass(unref(cn)("flex min-w-0 flex-col gap-3 border-0 p-0", props.class)),
+        "data-invalid": invalid.value || void 0
+      }, [
+        props.label !== false && props.label !== "" ? (openBlock(), createElementBlock("legend", _hoisted_2, [
+          createVNode(_sfc_main$1, {
+            label: props.label,
+            source: props.source
+          }, null, 8, ["label", "source"]),
+          unref(input).isRequired ? (openBlock(), createElementBlock("span", _hoisted_3, " *")) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true),
+        !props.disabled ? (openBlock(), createBlock(_sfc_main$2, {
+          key: 1,
+          active: tool.value,
+          "onUpdate:active": _cache[0] || (_cache[0] = ($event) => tool.value = $event),
+          tools: props.tools ?? defaultTools(props.kind),
+          "can-delete": (controls.value?.selectedId.value ?? null) !== null,
+          onDelete: _cache[1] || (_cache[1] = ($event) => controls.value?.deleteSelected())
+        }, null, 8, ["active", "tools", "can-delete"])) : createCommentVNode("", true),
+        createVNode(_sfc_main$3, {
+          center: props.defaultCenter,
+          zoom: props.zoom,
+          height: props.height,
+          "map-style": props.mapStyle
+        }, {
+          default: withCtx(() => [
+            createVNode(unref(Editor), {
+              features: draft.value,
+              held: held.value,
+              tool: tool.value,
+              disabled: props.disabled,
+              snappable: props.snappable,
+              "snap-distance": props.snapDistance,
+              "shape-style": props.shapeStyle,
+              fit: props.fitBounds,
+              "get-value": () => unref(input).value.value,
+              written,
+              onEdit,
+              onControls: _cache[2] || (_cache[2] = ($event) => controls.value = $event)
+            }, null, 8, ["features", "held", "tool", "disabled", "snappable", "snap-distance", "shape-style", "fit", "get-value"])
+          ]),
+          _: 1
+        }, 8, ["center", "zoom", "height", "map-style"]),
+        (controls.value?.refused.value.length ?? 0) > 0 ? (openBlock(), createElementBlock("p", _hoisted_4, toDisplayString(unref(translate)("chelone.map.shape_not_shown", {
+          _: "Part of this shape cannot be shown on the map"
+        })), 1)) : createCommentVNode("", true),
+        createVNode(_sfc_main$4, {
+          "helper-text": props.helperText
+        }, null, 8, ["helper-text"]),
+        invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 3 }, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$5, {
+              error: unref(input).error.value
+            }, null, 8, ["error"])
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps-draw/shape-input2.vue.js

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

package/dist/components/maps-draw/shape-inputs.d.ts

@@ -0,0 +1,135 @@
+import type { RoutingProvider, ShapeValue } from "@chelone/core";
+import { type ShapeInputProps } from "./shape-input.vue.js";
+import type { DrawTool } from "./use-terra-draw.js";
+type ToolbarTool = DrawTool | "delete";
+/** The props of every input in this file: those of `ShapeInput`, but for `kind`. */
+export type GeoJsonInputBaseProps = Omit<ShapeInputProps, "kind">;
+/** A geometry type a drawing can produce. A Multi type draws with its single's tools. */
+export type GeometryShape = "Point" | "MultiPoint" | "LineString" | "MultiLineString" | "Polygon" | "MultiPolygon";
+/**
+ * The toolbar for drawing `shapes`: each shape's draw tools in the order of
+ * `shapes`, none twice, `cut` when a polygon shape is in play, then `edit`,
+ * `move` and `delete`.
+ */
+export declare function toolsForShapes(shapes: readonly GeometryShape[]): ToolbarTool[];
+/**
+ * Edits a GeoJSON Point by drawing on a map. A new point replaces the old one.
+ *
+ * @example
+ * <PointInput source="location" label="Location" />
+ */
+export declare const PointInput: import("vue").DefineSetupFnComponent<GeoJsonInputBaseProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputBaseProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+/** Edits a GeoJSON MultiPoint. Each point is its own editable feature. */
+export declare const MultiPointInput: import("vue").DefineSetupFnComponent<GeoJsonInputBaseProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputBaseProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+export interface LineStringInputProps extends GeoJsonInputBaseProps {
+    /**
+     * Snap each line the user draws or edits to the road network. `true` uses the
+     * `router` of `MapsProvider`; a `RoutingProvider` is used as given. A saved
+     * line is left alone until the user edits it, and a failed snap keeps the
+     * drawn line. Takes the place of `refine`.
+     */
+    snapToRoads?: boolean | RoutingProvider;
+}
+/**
+ * Edits a GeoJSON LineString. A new line replaces the old one.
+ *
+ * @example
+ * <LineStringInput source="route" snap-to-roads />
+ */
+export declare const LineStringInput: import("vue").DefineSetupFnComponent<LineStringInputProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, LineStringInputProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+/** Edits a GeoJSON MultiLineString. Each line is its own editable feature. */
+export declare const MultiLineStringInput: import("vue").DefineSetupFnComponent<GeoJsonInputBaseProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputBaseProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+/** Edits a GeoJSON Polygon. A new drawing replaces the old one. */
+export declare const PolygonInput: import("vue").DefineSetupFnComponent<GeoJsonInputBaseProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputBaseProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+/**
+ * Edits a GeoJSON MultiPolygon. Each part is its own editable feature; a part
+ * with a hole draws read-only and stays in the value.
+ */
+export declare const MultiPolygonInput: import("vue").DefineSetupFnComponent<GeoJsonInputBaseProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputBaseProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+/** Edits a GeoJSON GeometryCollection with every draw tool. Every shape stays. */
+export declare const GeometryCollectionInput: import("vue").DefineSetupFnComponent<GeoJsonInputBaseProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputBaseProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+export interface GeoJsonInputProps extends GeoJsonInputBaseProps {
+    /** The shapes the user may draw. Defaults to all three. */
+    shapes?: readonly ("Point" | "LineString" | "Polygon")[];
+    /**
+     * Store a GeometryCollection that keeps every shape. Otherwise the value is
+     * one geometry and a new drawing replaces the old one. Defaults to false.
+     */
+    collection?: boolean;
+}
+/**
+ * Edits any one GeoJSON geometry, or with `collection` a GeometryCollection,
+ * limited to the drawn `shapes`.
+ *
+ * @example
+ * <GeoJsonInput source="geometry" :shapes="['Point', 'Polygon']" />
+ */
+export declare const GeoJsonInput: import("vue").DefineSetupFnComponent<GeoJsonInputProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, GeoJsonInputProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+export interface FeatureInputProps extends GeoJsonInputBaseProps {
+    /**
+     * The geometry type the feature holds, which picks the tools. Defaults to
+     * `Polygon`. A Multi type offers its single's tools, and a drawing stores
+     * that single geometry.
+     */
+    shape?: GeometryShape;
+}
+/**
+ * Edits a GeoJSON Feature. An edit keeps the feature's `id` and `properties`.
+ *
+ * @example
+ * <FeatureInput source="place" shape="Point" />
+ */
+export declare const FeatureInput: import("vue").DefineSetupFnComponent<FeatureInputProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, FeatureInputProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+export interface FeatureCollectionInputProps extends GeoJsonInputBaseProps {
+    /** The shapes the user may draw. Defaults to `Point`, `LineString` and `Polygon`. */
+    allowedShapes?: readonly GeometryShape[];
+}
+/**
+ * Edits a GeoJSON FeatureCollection. Each feature keeps its own `properties`
+ * when another is removed.
+ *
+ * @example
+ * <FeatureCollectionInput source="places" :allowed-shapes="['Point']" />
+ */
+export declare const FeatureCollectionInput: import("vue").DefineSetupFnComponent<FeatureCollectionInputProps, {
+    commit: (_value: ShapeValue | null) => boolean;
+}, {}, FeatureCollectionInputProps & {
+    onCommit?: ((_value: ShapeValue | null) => any) | undefined;
+}, import("vue").PublicProps>;
+export {};