@chelone/vue 0.5.0 → 0.7.0

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

@@ -1,22 +1 @@
-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>;
+export { type FetchOsmFeaturesOptions, fetchOsmFeatures, hasOsmSources, osmToPolygons, } from "@chelone/utils/osm";

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

@@ -1,67 +1 @@
-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
-};
+export { fetchOsmFeatures, hasOsmSources, osmToPolygons } from "@chelone/utils/osm";

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

@@ -1,16 +1 @@
-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 {};
+export { subtractMask, unionAll } from "@chelone/utils/osm";

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

@@ -1,41 +1 @@
-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
-};
+export { subtractMask, unionAll } from "@chelone/utils/osm";

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

@@ -0,0 +1,4 @@
+import reverse_geocode_field_vue_vue_type_script_setup_true_lang_default from "./reverse-geocode-field.vue_vue_type_script_setup_true_lang.js";
+// src/components/maps-osm/reverse-geocode-field.vue
+var reverse_geocode_field_default = reverse_geocode_field_vue_vue_type_script_setup_true_lang_default;
+export { reverse_geocode_field_default as default };

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

@@ -1,21 +1,33 @@
 import type { GeocodingProvider, SourceProp } from "@chelone/core";
 /** Props for {@link ReverseGeocodeField}. */
-export interface ReverseGeocodeFieldProps {
+export interface ReverseGeocodeFieldProps<TRecord = unknown> {
     /** The record property holding the latitude. */
     latSource: SourceProp;
     /** The record property holding the longitude. */
     lngSource: SourceProp;
     /** Defaults to the ambient record. */
-    record?: Record<string, unknown>;
+    record?: TRecord;
     /** `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>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: <TRecord>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<ReverseGeocodeFieldProps<TRecord>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,53 @@
+import { cn } from "../../lib/utils.js";
+import { useCoordinates } from "../maps/use-coordinates.js";
+import skeleton_default from "../ui/skeleton.js";
+import { useReverseGeocode } from "./use-reverse-geocode.js";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createTextVNode, defineComponent, normalizeClass, openBlock, toDisplayString, unref } from "vue";
+// src/components/maps-osm/reverse-geocode-field.vue?vue&type=script&setup=true&lang.ts
+var reverse_geocode_field_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "reverse-geocode-field",
+	props: {
+		latSource: {},
+		lngSource: {},
+		record: { default: void 0 },
+		format: { default: "full" },
+		provider: { default: void 0 },
+		class: {}
+	},
+	setup(__props) {
+		/**
+		* Names the position held in two record fields, such as the address of a
+		* saved point. Renders nothing without both coordinates, a skeleton while the
+		* lookup runs, and the rounded coordinates when the provider knows no place.
+		*
+		* Needs a geocoding provider, from the `provider` prop or `MapsProvider`'s
+		* `geocoder`; with neither it throws.
+		*
+		* @example
+		* <ReverseGeocodeField lat-source="latitude" lng-source="longitude" format="city" />
+		*/
+		const props = __props;
+		const { lat, lng } = useCoordinates(props);
+		const found = useReverseGeocode(() => ({
+			lat: lat.value ?? NaN,
+			lng: lng.value ?? 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;
+			return name.split(",").map((part) => part.trim()).slice(0, props.format === "street" ? 1 : 2).join(", ");
+		});
+		return (_ctx, _cache) => {
+			return unref(lat) !== null && unref(lng) !== 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(skeleton_default, {
+				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 { reverse_geocode_field_vue_vue_type_script_setup_true_lang_default as default };

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

@@ -1,4 +1,4 @@
-import { type GeoBBox, type GeocodeResult, type GeocodingProvider } from "@chelone/core";
+import { type GeocodeResult, type GeocodingProvider, type LngLatBox } from "@chelone/core";
 import { type MaybeRefOrGetter } from "vue";
 export interface UseGeocodeOptions {
     /** Defaults to the `geocoder` of `MapsProvider`. One of the two is required. */
@@ -12,7 +12,7 @@ export interface UseGeocodeOptions {
     /** ISO 3166-1 alpha-2 codes to restrict the search to. */
     countryCodes?: string[];
     /** `[west, south, east, north]` to favour or restrict hits to. */
-    viewBox?: GeoBBox;
+    viewBox?: LngLatBox;
     limit?: number;
 }
 /**

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

@@ -1,46 +1,53 @@
+import { useMapsConfig } from "../maps/use-map.js";
+import { computed, onScopeDispose, ref, toValue, watch } from "vue";
 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";
+// src/components/maps-osm/use-geocode.ts
+/** `source`, held back until it has stayed the same for `delayMs`. */
 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;
+	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;
 }
+/**
+* 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 });
+*/
 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);
+	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
-};
+export { useGeocode };

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

@@ -1,4 +1,5 @@
-import { type GeoBBox, type GeoFeatureCollection, type OverpassProvider, type OverpassQuerySources } from "@chelone/core";
+import { type JsonObject, type LngLatBox, type OverpassProvider, type OverpassQuerySources } from "@chelone/core";
+import type { FeatureCollection, Geometry } from "geojson";
 import { type MaybeRefOrGetter } from "vue";
 export interface UseOsmFeaturesOptions {
     /** Defaults to the `overpass` of `MapsProvider`. One of the two is required. */
@@ -19,4 +20,4 @@ export interface UseOsmFeaturesOptions {
  * @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>;
+export declare function useOsmFeatures(bbox: MaybeRefOrGetter<LngLatBox | null>, sources: MaybeRefOrGetter<OverpassQuerySources>, options?: UseOsmFeaturesOptions): import("@tanstack/vue-query").UseQueryReturnType<FeatureCollection<Geometry | null, JsonObject | null>, Error>;

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

@@ -1,37 +1,38 @@
-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";
+import { computed, toValue } from "vue";
+import { buildOverpassQuery, overpassQueryOptions } from "@chelone/core";
+import { useQuery } from "@tanstack/vue-query";
+// src/components/maps-osm/use-osm-features.ts
+/**
+* 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 });
+*/
 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);
+	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
-};
+export { useOsmFeatures };

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

@@ -1,25 +1,33 @@
+import { useMapsConfig } from "../maps/use-map.js";
+import { computed, toValue } from "vue";
 import { reverseGeocodeQueryOptions } from "@chelone/core";
 import { useQuery } from "@tanstack/vue-query";
-import { computed, toValue } from "vue";
-import { useMapsConfig } from "../maps/use-map.js";
+// src/components/maps-osm/use-reverse-geocode.ts
+/**
+* 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 });
+*/
 function useReverseGeocode(position, options = {}) {
-  const config = useMapsConfig();
-  const resolve = () => options.provider ?? config.geocoder;
-  if (!resolve()) {
-    throw new Error(
-      "useReverseGeocode needs a geocoding provider: pass the `provider` option or set `geocoder` on <MapsProvider>."
-    );
-  }
-  const request = computed(() => {
-    const provider = resolve();
-    if (!provider) {
-      throw new Error("useReverseGeocode lost its geocoding provider.");
-    }
-    const base = reverseGeocodeQueryOptions(provider, toValue(position));
-    return { ...base, enabled: (options.enabled ?? true) && base.enabled };
-  });
-  return useQuery(request);
+	const config = useMapsConfig();
+	const resolve = () => options.provider ?? config.geocoder;
+	if (!resolve()) throw new Error("useReverseGeocode needs a geocoding provider: pass the `provider` option or set `geocoder` on <MapsProvider>.");
+	const request = computed(() => {
+		const provider = resolve();
+		if (!provider) throw new Error("useReverseGeocode lost its geocoding provider.");
+		const base = reverseGeocodeQueryOptions(provider, toValue(position));
+		return {
+			...base,
+			enabled: (options.enabled ?? true) && base.enabled
+		};
+	});
+	return useQuery(request);
 }
-export {
-  useReverseGeocode
-};
+export { useReverseGeocode };

package/dist/components/mdx-editor/internal/crepe-editor.js

@@ -0,0 +1,4 @@
+import crepe_editor_vue_vue_type_script_setup_true_lang_default from "./crepe-editor.vue_vue_type_script_setup_true_lang.js";
+// src/components/mdx-editor/internal/crepe-editor.vue
+var crepe_editor_default = crepe_editor_vue_vue_type_script_setup_true_lang_default;
+export { crepe_editor_default as default };

package/dist/components/mdx-editor/internal/crepe-editor.vue.d.ts

@@ -1,7 +1,9 @@
 import type { CrepeConfig } from "@milkdown/crepe";
 /** The Crepe options an app may set; the editor owns `root` and `defaultValue`. */
 export type CrepeEditorConfig = Pick<CrepeConfig, "features" | "featureConfigs">;
-declare const _default: import("vue").DefineComponent<{
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
     markdown: string;
     readonly: boolean;
     crepeConfig?: CrepeEditorConfig;
@@ -16,4 +18,3 @@ declare const _default: import("vue").DefineComponent<{
     onBlur?: (() => any) | undefined;
     onChange?: ((markdown: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/components/mdx-editor/internal/crepe-editor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,101 @@
+/* empty css                  */
+import { createElementBlock, defineComponent, onBeforeUnmount, onMounted, openBlock, useTemplateRef, watch } from "vue";
+import { Crepe } from "@milkdown/crepe";
+import "@milkdown/crepe/theme/common/style.css";
+import { replaceAll } from "@milkdown/kit/utils";
+// src/components/mdx-editor/internal/crepe-editor.vue?vue&type=script&setup=true&lang.ts
+var crepe_editor_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "crepe-editor",
+	props: {
+		markdown: {},
+		readonly: { type: Boolean },
+		crepeConfig: {}
+	},
+	emits: ["change", "blur"],
+	setup(__props, { emit: __emit }) {
+		/**
+		* The only file that builds a Crepe editor. The editor is uncontrolled, so
+		* `markdown` is pushed in on change, and a `markdownUpdated` that carries the
+		* text the parent already holds is not reported back as an edit.
+		*
+		* Milkdown re-serializes what it holds (it ends the text with a newline and may
+		* change markers), so the prop never equals `getMarkdown()` byte for byte. The
+		* editor's own serialization of the last prop it received is remembered in
+		* `applied` and compared in its place.
+		*/
+		const props = __props;
+		const emit = __emit;
+		const root = useTemplateRef("root");
+		let crepe;
+		let ready = false;
+		let unmounted = false;
+		/** A prop value, and what the editor serialized after it took that value in. */
+		let applied;
+		function pushMarkdown(next) {
+			if (!crepe || !ready) return;
+			const current = crepe.getMarkdown();
+			if (current === next) return;
+			if (applied?.prop === next && applied.serialized === current) return;
+			crepe.editor.action(replaceAll(next));
+			applied = {
+				prop: next,
+				serialized: crepe.getMarkdown()
+			};
+		}
+		/** The editor reporting text it holds because of the prop, not because of an edit. */
+		function isOwnText(markdown) {
+			return markdown === props.markdown || applied?.prop === props.markdown && applied.serialized === markdown;
+		}
+		onMounted(async () => {
+			const { features, featureConfigs, ...rest } = props.crepeConfig ?? {};
+			const initial = props.markdown;
+			const instance = new Crepe({
+				...rest,
+				root: root.value,
+				defaultValue: initial,
+				features: {
+					...features,
+					[Crepe.Feature.CodeMirror]: false,
+					[Crepe.Feature.Latex]: false
+				},
+				featureConfigs
+			});
+			crepe = instance;
+			instance.on((api) => {
+				api.markdownUpdated((_ctx, markdown) => {
+					if (!isOwnText(markdown)) emit("change", markdown);
+				});
+				api.blur(() => emit("blur"));
+			});
+			await instance.create();
+			if (unmounted) {
+				await instance.destroy();
+				return;
+			}
+			instance.setReadonly(props.readonly);
+			ready = true;
+			applied = {
+				prop: initial,
+				serialized: instance.getMarkdown()
+			};
+			pushMarkdown(props.markdown);
+		});
+		watch(() => props.markdown, (next) => pushMarkdown(next));
+		watch(() => props.readonly, (next) => {
+			if (ready) crepe?.setReadonly(next);
+		});
+		onBeforeUnmount(() => {
+			unmounted = true;
+			if (ready) crepe?.destroy();
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "root",
+				ref: root,
+				"data-slot": "mdx-editor",
+				class: "chelone-mdx-editor"
+			}, null, 512);
+		};
+	}
+});
+export { crepe_editor_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/mdx-editor/mdx-field.js

@@ -0,0 +1,4 @@
+import mdx_field_vue_vue_type_script_setup_true_lang_default from "./mdx-field.vue_vue_type_script_setup_true_lang.js";
+// src/components/mdx-editor/mdx-field.vue
+var mdx_field_default = mdx_field_vue_vue_type_script_setup_true_lang_default;
+export { mdx_field_default as default };