@chelone/vue 0.0.0-stage → 0.1.1

package/dist/components/maps/geo-json-layers.vue.js

@@ -0,0 +1,41 @@
+import { defineComponent, computed, toRaw, watch } from "vue";
+import { asFeatureCollection, geoBounds, isLngLatBox } from "@chelone/core";
+import { useGeoJsonSource, uniqueGeoJsonSourceId } from "./use-geo-json-source.js";
+import { useMap } from "./use-map.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "geo-json-layers",
+  props: {
+    data: {},
+    shapeStyle: {},
+    fitBounds: { type: Boolean, default: true },
+    fitPadding: { default: 20 },
+    maxFitZoom: { default: 18 }
+  },
+  setup(__props) {
+    const props = __props;
+    const map = useMap();
+    const value = computed(() => toRaw(props.data));
+    const collection = computed(() => asFeatureCollection(value.value));
+    useGeoJsonSource(uniqueGeoJsonSourceId(), collection, () => props.shapeStyle ?? {});
+    const box = computed(() => geoBounds(value.value));
+    const boxKey = computed(() => box.value ? box.value.join(",") : "");
+    watch(
+      [() => props.fitBounds, boxKey],
+      () => {
+        if (!props.fitBounds || !isLngLatBox(box.value)) return;
+        map.fitBounds(box.value, {
+          padding: props.fitPadding,
+          maxZoom: props.maxFitZoom,
+          duration: 0
+        });
+      },
+      { immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return null;
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps/geo-json-layers2.vue.js

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

package/dist/components/maps/geo-json-view.vue.d.ts

@@ -0,0 +1,19 @@
+import type { MapStyleInput } from "@chelone/core";
+import type { GeoJsonLayersProps } from "./geo-json-layers.vue.js";
+/** Props for {@link GeoJsonView}. */
+export interface GeoJsonViewProps extends GeoJsonLayersProps {
+    /** In pixels, or any CSS length. Defaults to 300. */
+    height?: number | string;
+    /** Defaults to the style from `MapsProvider`. */
+    mapStyle?: MapStyleInput;
+    /** Zoom with the mouse wheel. Defaults to false so the page still scrolls. */
+    scrollZoom?: boolean;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<GeoJsonViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GeoJsonViewProps> & Readonly<{}>, {
+    scrollZoom: boolean;
+    fitBounds: boolean;
+    fitPadding: number;
+    maxFitZoom: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/maps/geo-json-view.vue.js

@@ -0,0 +1,42 @@
+import { defineComponent, openBlock, createBlock, normalizeClass, withCtx, createVNode } from "vue";
+import _sfc_main$2 from "./geo-json-layers.vue.js";
+import _sfc_main$1 from "./map-canvas.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "geo-json-view",
+  props: {
+    height: {},
+    mapStyle: {},
+    scrollZoom: { type: Boolean, default: false },
+    class: {},
+    data: {},
+    shapeStyle: {},
+    fitBounds: { type: Boolean, default: true },
+    fitPadding: { default: 20 },
+    maxFitZoom: { default: 18 }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, {
+        height: props.height,
+        "map-style": props.mapStyle,
+        "scroll-zoom": props.scrollZoom,
+        class: normalizeClass(props.class)
+      }, {
+        default: withCtx(() => [
+          createVNode(_sfc_main$2, {
+            data: props.data,
+            "shape-style": props.shapeStyle,
+            "fit-bounds": props.fitBounds,
+            "fit-padding": props.fitPadding,
+            "max-fit-zoom": props.maxFitZoom
+          }, null, 8, ["data", "shape-style", "fit-bounds", "fit-padding", "max-fit-zoom"])
+        ]),
+        _: 1
+      }, 8, ["height", "map-style", "scroll-zoom", "class"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps/geo-json-view2.vue.js

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

package/dist/components/maps/lat-lng-field.vue.d.ts

@@ -0,0 +1,18 @@
+import type { MapStyleInput } from "@chelone/core";
+/** Props for {@link LatLngField}. */
+export interface LatLngFieldProps {
+    /** 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>;
+    zoom?: number;
+    /** In pixels, or any CSS length. Defaults to 300. */
+    height?: number | string;
+    /** Defaults to the style from `MapsProvider`. */
+    mapStyle?: MapStyleInput;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<LatLngFieldProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LatLngFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/maps/lat-lng-field.vue.js

@@ -0,0 +1,76 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeStyle, normalizeClass, unref, toDisplayString, createBlock, withCtx, createVNode } from "vue";
+import { toCoordinate } from "@chelone/core";
+import { useTranslate } from "../../i18n/use-translate.js";
+import { cn } from "../../lib/utils.js";
+import { useFieldValue } from "../../record/use-field-value.js";
+import _sfc_main$1 from "./map-canvas.vue.js";
+import { MapMarker } from "./use-map.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "lat-lng-field",
+  props: {
+    latSource: {},
+    lngSource: {},
+    record: {},
+    zoom: {},
+    height: {},
+    mapStyle: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const translate = useTranslate();
+    const latValue = useFieldValue({
+      source: props.latSource,
+      record: props.record
+    });
+    const lngValue = useFieldValue({
+      source: props.lngSource,
+      record: props.record
+    });
+    function inRange(value, limit) {
+      return value !== null && Math.abs(value) <= limit ? value : null;
+    }
+    const lat = computed(() => inRange(toCoordinate(latValue.value), 90));
+    const lng = computed(() => inRange(toCoordinate(lngValue.value), 180));
+    const cssHeight = computed(() => {
+      const height = props.height ?? 300;
+      return typeof height === "number" ? `${height}px` : height;
+    });
+    return (_ctx, _cache) => {
+      return lat.value === null || lng.value === null ? (openBlock(), createElementBlock("div", {
+        key: 0,
+        "data-slot": "lat-lng-field-empty",
+        class: normalizeClass(
+          unref(cn)(
+            "flex items-center justify-center rounded-md border border-dashed text-sm text-muted-foreground",
+            props.class
+          )
+        ),
+        style: normalizeStyle({ height: cssHeight.value })
+      }, toDisplayString(unref(translate)("chelone.map.no_coordinates", { _: "No coordinates available" })), 7)) : (openBlock(), createElementBlock("div", {
+        key: 1,
+        "data-slot": "lat-lng-field",
+        class: normalizeClass(props.class)
+      }, [
+        (openBlock(), createBlock(_sfc_main$1, {
+          key: `${lat.value},${lng.value}`,
+          center: [lat.value, lng.value],
+          zoom: props.zoom,
+          height: props.height,
+          "map-style": props.mapStyle,
+          "scroll-zoom": false
+        }, {
+          default: withCtx(() => [
+            createVNode(unref(MapMarker), {
+              position: [lat.value, lng.value]
+            }, null, 8, ["position"])
+          ]),
+          _: 1
+        }, 8, ["center", "zoom", "height", "map-style"]))
+      ], 2));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps/lat-lng-field2.vue.js

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

package/dist/components/maps/lat-lng-input.vue.d.ts

@@ -0,0 +1,38 @@
+import type { MapStyleInput, Validator } from "@chelone/core";
+/** Props for {@link LatLngInput}. */
+export interface LatLngInputProps {
+    /** The form field holding the latitude. */
+    latSource: string;
+    /** The form field holding the longitude. */
+    lngSource: string;
+    /** The legend. A string is translated; `false` renders none. */
+    label?: string | false;
+    helperText?: string;
+    /** Run after the -90..90 range check. */
+    latValidate?: Validator | readonly Validator[];
+    /** Run after the -180..180 range check. */
+    lngValidate?: Validator | readonly Validator[];
+    /** `[lat, lng]`. The map centre while either field is empty. Defaults to `[0, 0]`. */
+    defaultPosition?: 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;
+    /** Disables both text fields and the pin; pan and zoom still work. */
+    disabled?: boolean;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<LatLngInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    positionChange: (lat: number, lng: number) => any;
+}, string, import("vue").PublicProps, Readonly<LatLngInputProps> & Readonly<{
+    onPositionChange?: ((lat: number, lng: number) => any) | undefined;
+}>, {
+    label: string | false;
+    disabled: boolean;
+    height: number | string;
+    zoom: number;
+    defaultPosition: readonly [lat: number, lng: number];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/maps/lat-lng-input.vue.js

@@ -0,0 +1,234 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, unref, toDisplayString, createCommentVNode, createElementVNode, Fragment, renderList, createBlock, withCtx, createVNode, ref, onBeforeUnmount, watch } from "vue";
+import { latitude, longitude, toCoordinate } 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$1 from "../admin/common/field-label-text.vue.js";
+import _sfc_main$4 from "../admin/common/input-helper-text.vue.js";
+import _sfc_main$3 from "../admin/common/validation-error.vue.js";
+import { Field, FieldLabel, FieldError } from "../ui/field.js";
+import _sfc_main$2 from "../ui/input.vue.js";
+import _sfc_main$5 from "./map-canvas.vue.js";
+import { MapMarker, useMap } from "./use-map.js";
+const _hoisted_1 = ["data-invalid"];
+const _hoisted_2 = {
+  key: 0,
+  class: "mb-1.5 text-sm font-medium"
+};
+const _hoisted_3 = { class: "grid grid-cols-2 gap-3" };
+const _hoisted_4 = { key: 0 };
+const positionKey = (position) => position ? `${position[0]},${position[1]}` : null;
+const MapBindings = defineComponent({
+  name: "LatLngInputMapBindings",
+  props: {
+    position: {
+      type: Array,
+      default: null
+    },
+    disabled: { type: Boolean, default: false },
+    gesture: { type: Object, required: true },
+    /** The centre the map was built with; `MapCanvas` reads it once, before `load`. */
+    built: {
+      type: Array,
+      required: true
+    }
+  },
+  emits: { place: (_lat, _lng) => true },
+  setup(props, { emit }) {
+    const map = useMap();
+    const onClick = (event) => {
+      if (props.disabled) return;
+      emit("place", event.lngLat.lat, event.lngLat.lng);
+    };
+    map.on("click", onClick);
+    onBeforeUnmount(() => {
+      map.off("click", onClick);
+    });
+    const start = props.position;
+    if (start && positionKey(start) !== positionKey(props.built)) {
+      map.easeTo({ center: [start[1], start[0]] });
+    }
+    watch(
+      () => positionKey(props.position),
+      (key) => {
+        const position = props.position;
+        if (key === null || !position) return;
+        const own = props.gesture.current;
+        props.gesture.current = null;
+        if (own && positionKey(own) === key) return;
+        map.easeTo({ center: [position[1], position[0]] });
+      }
+    );
+    return () => null;
+  }
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "lat-lng-input",
+  props: {
+    latSource: {},
+    lngSource: {},
+    label: { type: [String, Boolean], default: void 0 },
+    helperText: {},
+    latValidate: {},
+    lngValidate: {},
+    defaultPosition: { default: () => [0, 0] },
+    zoom: { default: 13 },
+    height: { default: 300 },
+    mapStyle: {},
+    disabled: { type: Boolean, default: false },
+    class: {}
+  },
+  emits: ["positionChange"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const translate = useTranslate();
+    const toText = (value) => typeof value === "number" ? `${value}` : "";
+    function toArray(validate) {
+      if (validate === void 0) return [];
+      return typeof validate === "function" ? [validate] : validate;
+    }
+    const round6 = (value) => Math.round(value * 1e6) / 1e6;
+    const wrapLng = (lng2) => Math.abs(lng2) <= 180 ? lng2 : ((lng2 + 180) % 360 + 360) % 360 - 180;
+    const TYPING = /^[+-]?\d*\.?\d*$/;
+    function inRange(value, limit) {
+      return value !== null && Math.abs(value) <= limit;
+    }
+    function useCoordinate(source, validate, range) {
+      const input = useInput({
+        source,
+        parse: toCoordinate,
+        format: (value) => toText(toCoordinate(value)),
+        validate: [range, ...validate]
+      });
+      const draft = ref(null);
+      const stored = computed(() => toCoordinate(input.value.value));
+      const text = computed(
+        () => draft.value !== null && toCoordinate(draft.value) === stored.value ? draft.value : input.value.value
+      );
+      return {
+        ...input,
+        stored,
+        invalid: computed(() => input.touched.value && input.error.value != null),
+        text,
+        onType(event) {
+          const element = event.target;
+          if (!TYPING.test(element.value)) {
+            element.value = text.value;
+            return;
+          }
+          draft.value = element.value;
+          input.setValue(element.value);
+        },
+        onBlur() {
+          if (draft.value !== null && toCoordinate(draft.value) === null) {
+            draft.value = null;
+          }
+          input.blur();
+        }
+      };
+    }
+    const lat = useCoordinate(props.latSource, toArray(props.latValidate), latitude());
+    const lng = useCoordinate(props.lngSource, toArray(props.lngValidate), longitude());
+    const fields = computed(() => [
+      { source: props.latSource, input: lat },
+      { source: props.lngSource, input: lng }
+    ]);
+    const position = computed(() => {
+      const a = lat.stored.value;
+      const b = lng.stored.value;
+      return inRange(a, 90) && inRange(b, 180) ? [a, b] : null;
+    });
+    const center = computed(() => position.value ?? props.defaultPosition);
+    const invalid = computed(() => lat.invalid.value || lng.invalid.value);
+    const built = center.value;
+    const gesture = { current: null };
+    function place(rawLat, rawLng) {
+      const nextLat = round6(rawLat);
+      const nextLng = round6(wrapLng(rawLng));
+      gesture.current = [nextLat, nextLng];
+      lat.setValue(nextLat);
+      lat.blur();
+      lng.setValue(nextLng);
+      lng.blur();
+      emit("positionChange", nextLat, nextLng);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("fieldset", {
+        "data-slot": "lat-lng-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 ? (openBlock(), createElementBlock("legend", _hoisted_2, toDisplayString(unref(translate)(props.label, { _: props.label })), 1)) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_3, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(fields.value, ({ source, input }) => {
+            return openBlock(), createBlock(unref(Field), {
+              key: source,
+              "data-invalid": input.invalid.value || void 0
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(FieldLabel), {
+                  "html-for": input.id
+                }, {
+                  default: withCtx(() => [
+                    createVNode(_sfc_main$1, { source }, null, 8, ["source"]),
+                    input.isRequired ? (openBlock(), createElementBlock("span", _hoisted_4, " *")) : createCommentVNode("", true)
+                  ]),
+                  _: 2
+                }, 1032, ["html-for"]),
+                createVNode(_sfc_main$2, {
+                  id: input.id,
+                  name: input.name,
+                  inputmode: "decimal",
+                  "model-value": input.text.value,
+                  disabled: props.disabled,
+                  "aria-invalid": input.invalid.value,
+                  onInput: input.onType,
+                  onBlur: input.onBlur
+                }, null, 8, ["id", "name", "model-value", "disabled", "aria-invalid", "onInput", "onBlur"]),
+                input.invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 0 }, {
+                  default: withCtx(() => [
+                    createVNode(_sfc_main$3, {
+                      error: input.error.value
+                    }, null, 8, ["error"])
+                  ]),
+                  _: 2
+                }, 1024)) : createCommentVNode("", true)
+              ]),
+              _: 2
+            }, 1032, ["data-invalid"]);
+          }), 128))
+        ]),
+        createVNode(_sfc_main$4, {
+          "helper-text": props.helperText
+        }, null, 8, ["helper-text"]),
+        createVNode(_sfc_main$5, {
+          center: center.value,
+          zoom: props.zoom,
+          height: props.height,
+          "map-style": props.mapStyle
+        }, {
+          default: withCtx(() => [
+            createVNode(unref(MapBindings), {
+              position: position.value,
+              built: unref(built),
+              disabled: props.disabled,
+              gesture,
+              onPlace: place
+            }, null, 8, ["position", "built", "disabled"]),
+            position.value ? (openBlock(), createBlock(unref(MapMarker), {
+              key: 0,
+              position: position.value,
+              draggable: !props.disabled,
+              onDragEnd: place
+            }, null, 8, ["position", "draggable"])) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["center", "zoom", "height", "map-style"])
+      ], 10, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps/lat-lng-input2.vue.js

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

package/dist/components/maps/map-canvas.vue.d.ts

@@ -0,0 +1,32 @@
+import type { MapStyleInput } from "@chelone/core";
+/** Props for {@link MapCanvas}. */
+export interface MapCanvasProps {
+    /** `[lat, lng]`. Read once at mount. Defaults to `[0, 0]`. */
+    center?: 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;
+    /**
+     * A MapLibre style URL, or a style object such as `rasterTileStyle(...)`.
+     * Read once at mount. Defaults to the one from `MapsProvider`.
+     */
+    mapStyle?: MapStyleInput;
+    /** Zoom with the mouse wheel. Defaults to true. */
+    scrollZoom?: boolean;
+    class?: string;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<MapCanvasProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MapCanvasProps> & Readonly<{}>, {
+    height: number | string;
+    center: readonly [lat: number, lng: number];
+    zoom: number;
+    scrollZoom: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/maps/map-canvas.vue.js

@@ -0,0 +1,82 @@
+import { defineComponent, ref, shallowRef, computed, onMounted, onBeforeUnmount, openBlock, createElementBlock, normalizeStyle, normalizeClass, unref, toDisplayString, renderSlot, createCommentVNode } from "vue";
+import { latLngToLngLat } from "@chelone/core";
+import { Map } from "maplibre-gl";
+import "maplibre-gl/dist/maplibre-gl.css";
+import { useTranslate } from "../../i18n/use-translate.js";
+import { cn } from "../../lib/utils.js";
+import { useMapsConfig, provideMap } from "./use-map.js";
+const _hoisted_1 = {
+  key: 0,
+  "data-slot": "map-canvas-error",
+  role: "alert",
+  class: "flex h-full items-center justify-center text-sm text-muted-foreground"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "map-canvas",
+  props: {
+    center: { default: () => [0, 0] },
+    zoom: { default: 13 },
+    height: { default: 300 },
+    mapStyle: {},
+    scrollZoom: { type: Boolean, default: true },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const style = props.mapStyle ?? useMapsConfig().mapStyle;
+    if (style === void 0) {
+      throw new Error(
+        'MapCanvas needs a basemap: pass the mapStyle prop, or wrap the app in <MapsProvider :map-style="...">. Build one with rasterTileStyle({ tileUrl, attribution }) or pass a MapLibre style URL.'
+      );
+    }
+    const container = ref(null);
+    const translate = useTranslate();
+    const map = shallowRef(null);
+    const failed = ref(false);
+    let created = null;
+    provideMap(map);
+    const cssHeight = computed(
+      () => typeof props.height === "number" ? `${props.height}px` : props.height
+    );
+    onMounted(() => {
+      const element = container.value;
+      if (!element) return;
+      const instance = new Map({
+        container: element,
+        style,
+        center: latLngToLngLat(props.center),
+        zoom: props.zoom,
+        scrollZoom: props.scrollZoom
+      });
+      created = instance;
+      instance.on("error", () => {
+        if (created === instance && map.value === null) failed.value = true;
+      });
+      instance.on("load", () => {
+        if (created !== instance) return;
+        failed.value = false;
+        map.value = instance;
+      });
+    });
+    onBeforeUnmount(() => {
+      const instance = created;
+      created = null;
+      map.value = null;
+      instance?.remove();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "container",
+        ref: container,
+        "data-slot": "map-canvas",
+        class: normalizeClass(unref(cn)("relative w-full overflow-hidden rounded-md", props.class)),
+        style: normalizeStyle({ height: cssHeight.value })
+      }, [
+        failed.value ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(unref(translate)("chelone.map.load_failed", { _: "The map could not be loaded" })), 1)) : map.value ? renderSlot(_ctx.$slots, "default", { key: 1 }) : createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/maps/map-canvas2.vue.js

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