@movk/maplibre 1.0.0

package/dist/runtime/composables/useMeasure.js

@@ -0,0 +1,173 @@
+import { onUnmounted, ref } from "vue";
+import { length } from "@turf/length";
+import { area } from "@turf/area";
+import { useContextResolver } from "../domains/map/resolve.js";
+import { formatArea, formatDistance } from "../utils/measure.js";
+import { logger } from "../utils/logger.js";
+import { textFontLayout } from "../domains/map/config.js";
+const SOURCE_ID = "movk-measure";
+export function useMeasure(options = {}) {
+  const color = options.color ?? "#f59e0b";
+  const resolve = useContextResolver(options.mapId);
+  const mode = ref();
+  const active = ref(false);
+  const result = ref("");
+  let finished = [];
+  let vertices = [];
+  let cursor;
+  let boundMap;
+  let stopReady;
+  function isAlive(map) {
+    return Boolean(map.getCanvas());
+  }
+  function setCursor(map, value) {
+    const canvas = map.getCanvas();
+    if (canvas) canvas.style.cursor = value;
+  }
+  function ensureLayers(map) {
+    if (!map.getSource(SOURCE_ID)) {
+      map.addSource(SOURCE_ID, { type: "geojson", data: collection() });
+    }
+    const layers = [
+      { id: `${SOURCE_ID}-fill`, type: "fill", filter: ["==", ["geometry-type"], "Polygon"], paint: { "fill-color": color, "fill-opacity": 0.15 } },
+      { id: `${SOURCE_ID}-line`, type: "line", filter: ["!=", ["geometry-type"], "Point"], paint: { "line-color": color, "line-width": 2, "line-dasharray": [2, 1] } },
+      { id: `${SOURCE_ID}-points`, type: "circle", filter: ["==", ["geometry-type"], "Point"], paint: { "circle-radius": 4, "circle-color": "#fff", "circle-stroke-color": color, "circle-stroke-width": 2 } },
+      { id: `${SOURCE_ID}-labels`, type: "symbol", filter: ["has", "label"], layout: { "text-field": ["get", "label"], "text-size": 13, "text-offset": [0, -1.2], "text-anchor": "bottom", ...textFontLayout() }, paint: { "text-color": color, "text-halo-color": "#fff", "text-halo-width": 1.5 } }
+    ];
+    for (const layer of layers) {
+      if (!map.getLayer(layer.id)) map.addLayer({ source: SOURCE_ID, ...layer });
+    }
+  }
+  function currentFeature() {
+    const coords = cursor ? [...vertices, cursor] : [...vertices];
+    if (mode.value === "area") {
+      if (coords.length < 3) return void 0;
+      return { type: "Feature", properties: {}, geometry: { type: "Polygon", coordinates: [[...coords, coords[0]]] } };
+    }
+    if (coords.length < 2) return void 0;
+    return { type: "Feature", properties: {}, geometry: { type: "LineString", coordinates: coords } };
+  }
+  function measureOf(feature) {
+    return feature.geometry.type === "Polygon" ? formatArea(area(feature)) : formatDistance(length(feature, { units: "kilometers" }) * 1e3);
+  }
+  function collection() {
+    const features = [...finished];
+    const current = currentFeature();
+    if (current) features.push(current);
+    for (const vertex of vertices) {
+      features.push({ type: "Feature", properties: {}, geometry: { type: "Point", coordinates: vertex } });
+    }
+    return { type: "FeatureCollection", features };
+  }
+  function refresh() {
+    const map = boundMap;
+    if (!map || !isAlive(map)) return;
+    const source = map.getSource(SOURCE_ID);
+    source?.setData(collection());
+    const current = currentFeature();
+    result.value = current ? measureOf(current) : "";
+  }
+  function onClick(event) {
+    vertices = [...vertices, [event.lngLat.lng, event.lngLat.lat]];
+    refresh();
+  }
+  function onMove(event) {
+    if (!vertices.length) return;
+    cursor = [event.lngLat.lng, event.lngLat.lat];
+    refresh();
+  }
+  function finishSegment() {
+    cursor = void 0;
+    const current = currentFeature();
+    if (current) {
+      const label = measureOf(current);
+      const anchor = vertices[vertices.length - 1];
+      finished = [
+        ...finished,
+        current,
+        { type: "Feature", properties: { label }, geometry: { type: "Point", coordinates: anchor } }
+      ];
+    }
+    vertices = [];
+    refresh();
+  }
+  function onDblClick(event) {
+    event.preventDefault();
+    vertices = vertices.slice(0, -1);
+    finishSegment();
+  }
+  function onKeydown(event) {
+    if (event.key !== "Escape") return;
+    vertices = [];
+    cursor = void 0;
+    refresh();
+  }
+  function start(nextMode) {
+    const ctx = resolve();
+    if (!ctx) {
+      logger.warn("useMeasure: no map context found; pass options.mapId or call inside <MaplibreMap>.");
+      return;
+    }
+    if (active.value) stop();
+    mode.value = nextMode;
+    active.value = true;
+    stopReady = ctx.onReady((map) => {
+      boundMap = map;
+      ensureLayers(map);
+      refresh();
+    });
+    void ctx.whenLoaded().then((map) => {
+      if (!active.value) return;
+      map.doubleClickZoom.disable();
+      setCursor(map, "crosshair");
+      map.on("click", onClick);
+      map.on("mousemove", onMove);
+      map.on("dblclick", onDblClick);
+      window.addEventListener("keydown", onKeydown);
+    });
+  }
+  function stop() {
+    if (!active.value) return;
+    active.value = false;
+    vertices = [];
+    cursor = void 0;
+    stopReady?.();
+    stopReady = void 0;
+    const map = boundMap;
+    if (map) {
+      map.off("click", onClick);
+      map.off("mousemove", onMove);
+      map.off("dblclick", onDblClick);
+      map.doubleClickZoom.enable();
+      setCursor(map, "");
+      refresh();
+    }
+    window.removeEventListener("keydown", onKeydown);
+    result.value = "";
+  }
+  function clear() {
+    finished = [];
+    vertices = [];
+    cursor = void 0;
+    refresh();
+  }
+  function teardown() {
+    stop();
+    const map = boundMap;
+    if (!map || !isAlive(map)) {
+      boundMap = void 0;
+      return;
+    }
+    for (const suffix of ["-fill", "-line", "-points", "-labels"]) {
+      const layerId = `${SOURCE_ID}${suffix}`;
+      if (map.getLayer(layerId)) map.removeLayer(layerId);
+    }
+    try {
+      if (map.getSource(SOURCE_ID)) map.removeSource(SOURCE_ID);
+    } catch {
+    }
+    boundMap = void 0;
+  }
+  onUnmounted(teardown);
+  return { start, stop, clear, mode, active, result };
+}

package/dist/runtime/domains/map/config.d.ts

@@ -0,0 +1,7 @@
+import type { MaplibreRuntimeConfig } from '../../types';
+export declare function setMaplibreConfig(value: Partial<MaplibreRuntimeConfig>): void;
+export declare function getMaplibreConfig(): MaplibreRuntimeConfig;
+/** 库内置文字图层的 layout 字体片段：配置了 textFont 才输出，否则交由样式默认 */
+export declare function textFontLayout(): {
+    'text-font'?: string[];
+};

package/dist/runtime/domains/map/config.js

@@ -0,0 +1,13 @@
+const STORE_KEY = Symbol.for("movk-maplibre:config");
+const globalScope = globalThis;
+const store = globalScope[STORE_KEY] ??= { config: {} };
+export function setMaplibreConfig(value) {
+  store.config = { ...store.config, ...value };
+}
+export function getMaplibreConfig() {
+  return store.config;
+}
+export function textFontLayout() {
+  const { textFont } = store.config;
+  return textFont ? { "text-font": textFont } : {};
+}

package/dist/runtime/domains/map/context.d.ts

@@ -0,0 +1,13 @@
+import type { InjectionKey } from 'vue';
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { MaplibreContext } from '../../types';
+/** MaplibreMap 向子组件下发上下文的注入键 */
+export declare const MaplibreContextKey: InjectionKey<MaplibreContext>;
+/**
+ * 创建上下文骨架（map 初始为 undefined），供 setup 阶段同步 provide。
+ * 实例就绪后由返回的 attach 挂载，避免把 provide 推迟到 onMounted。
+ */
+export declare function createMaplibreContext(id: string): {
+    context: MaplibreContext;
+    attach: (map: MaplibreMap) => void;
+};

package/dist/runtime/domains/map/context.js

@@ -0,0 +1,51 @@
+import { ref, shallowRef } from "vue";
+export const MaplibreContextKey = Symbol("movk-maplibre:context");
+export function createMaplibreContext(id) {
+  const map = shallowRef();
+  const isLoaded = ref(false);
+  const readyCallbacks = /* @__PURE__ */ new Set();
+  let resolveLoaded;
+  const loadedPromise = new Promise((resolve) => {
+    resolveLoaded = resolve;
+  });
+  function attach(instance) {
+    map.value = instance;
+    instance.on("load", () => {
+      isLoaded.value = true;
+      resolveLoaded(instance);
+    });
+    instance.on("style.load", () => {
+      for (const callback of readyCallbacks) callback(instance);
+    });
+  }
+  const context = {
+    id,
+    map,
+    isLoaded,
+    whenLoaded: () => loadedPromise,
+    onReady(callback) {
+      readyCallbacks.add(callback);
+      const unregister = () => readyCallbacks.delete(callback);
+      const instance = map.value;
+      if (!instance) {
+        return unregister;
+      }
+      if (instance.isStyleLoaded()) {
+        callback(instance);
+        return unregister;
+      }
+      const events = ["styledata", "sourcedata", "idle"];
+      const onData = () => {
+        if (!instance.isStyleLoaded()) return;
+        for (const e of events) instance.off(e, onData);
+        if (readyCallbacks.has(callback)) callback(instance);
+      };
+      for (const e of events) instance.on(e, onData);
+      return () => {
+        unregister();
+        for (const e of events) instance.off(e, onData);
+      };
+    }
+  };
+  return { context, attach };
+}

package/dist/runtime/domains/map/control.d.ts

@@ -0,0 +1,4 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { ControlPosition, IControl } from 'maplibre-gl';
+/** 控件组件共享逻辑：地图就绪后 addControl；position/options 变化时移除并按新配置重建；卸载时 removeControl。 */
+export declare function useControl(create: () => IControl, position?: MaybeRefOrGetter<ControlPosition | undefined>, watchSource?: () => unknown): void;

package/dist/runtime/domains/map/control.js

@@ -0,0 +1,28 @@
+import { onMounted, onUnmounted, toValue, watch } from "vue";
+import { useMap } from "../../composables/useMap.js";
+export function useControl(create, position, watchSource) {
+  const ctx = useMap();
+  let control;
+  function rebuild() {
+    const map = ctx.map.value;
+    if (!map) return;
+    if (control) map.removeControl(control);
+    control = create();
+    map.addControl(control, toValue(position));
+  }
+  onMounted(async () => {
+    await ctx.whenLoaded();
+    rebuild();
+  });
+  watch(
+    () => [toValue(position), watchSource?.()],
+    () => {
+      if (control) rebuild();
+    },
+    { deep: true }
+  );
+  onUnmounted(() => {
+    if (control) ctx.map.value?.removeControl(control);
+    control = void 0;
+  });
+}

package/dist/runtime/domains/map/create-map.d.ts

@@ -0,0 +1,3 @@
+import type { Map as MaplibreMap, MapOptions } from 'maplibre-gl';
+/** 应用全局配置并创建 maplibre-gl 实例。仅在客户端调用。 */
+export declare function createMaplibreGl(options: MapOptions): MaplibreMap;

package/dist/runtime/domains/map/create-map.js

@@ -0,0 +1,21 @@
+import { Map as MaplibreGlMap, prewarm, setRTLTextPlugin, setWorkerCount, setWorkerUrl } from "maplibre-gl";
+import { logger } from "../../utils/logger.js";
+import { getMaplibreConfig } from "./config.js";
+const DEFAULT_RTL_PLUGIN = "https://cdn.jsdelivr.net/npm/@mapbox/mapbox-gl-rtl-text@0.3.0/dist/mapbox-gl-rtl-text.js";
+let globalConfigApplied = false;
+function applyGlobalConfig() {
+  if (globalConfigApplied) return;
+  globalConfigApplied = true;
+  const config = getMaplibreConfig();
+  if (config.workerUrl) setWorkerUrl(config.workerUrl);
+  if (config.workerCount) setWorkerCount(config.workerCount);
+  if (config.prewarm) prewarm();
+  if (config.RTLTextPlugin) {
+    const plugin = typeof config.RTLTextPlugin === "boolean" ? {} : config.RTLTextPlugin;
+    setRTLTextPlugin(plugin.pluginURL || DEFAULT_RTL_PLUGIN, plugin.lazy ?? false).catch((error) => logger.warn("Failed to load RTL text plugin", error));
+  }
+}
+export function createMaplibreGl(options) {
+  applyGlobalConfig();
+  return new MaplibreGlMap(options);
+}

package/dist/runtime/domains/map/draw-context.d.ts

@@ -0,0 +1,26 @@
+import type { GeoJSONStoreFeatures, TerraDraw, TerraDrawExtend } from 'terra-draw';
+import type { Feature, FeatureCollection, Geometry } from 'geojson';
+import type { MaplibreDrawContext } from '../../types';
+type FeatureId = TerraDrawExtend.FeatureId;
+/** 控件把受控模型的回写通道交给上下文，绘制指令与模型同步因此只有一处实现 */
+export interface DrawContextCallbacks {
+    /** 要素集合变更后回写 v-model:features */
+    onFeatures: (features: Feature[]) => void;
+    /** 模式变更后回写 v-model:mode */
+    onMode: (mode: string) => void;
+}
+/** 已完成的要素：排除绘制中的要素与编辑辅助点 */
+export declare function committedFeatures(draw: TerraDraw): GeoJSONStoreFeatures[];
+/** 规范化为 terra-draw store 要素：补 id 与 mode，跳过不支持的几何 */
+export declare function toStoreFeatures(draw: TerraDraw, geojson: Feature | FeatureCollection | Geometry): GeoJSONStoreFeatures[];
+/** 添加要素并返回通过校验的 id，未通过的逐个告警 */
+export declare function addStoreFeatures(draw: TerraDraw, features: GeoJSONStoreFeatures[]): FeatureId[];
+/**
+ * 创建绘制上下文骨架（draw 初始为 undefined），供 setup 阶段同步 provide 与注册。
+ * 实例在控件 onMounted 里创建后由返回的 attach 挂载并 resolve whenReady。
+ */
+export declare function createDrawContext(mapId: string, callbacks: DrawContextCallbacks): {
+    context: MaplibreDrawContext;
+    attach: (draw: TerraDraw) => void;
+};
+export {};

package/dist/runtime/domains/map/draw-context.js

@@ -0,0 +1,73 @@
+import { shallowRef } from "vue";
+import { logger } from "../../utils/logger.js";
+const GUIDANCE_KEYS = ["currentlyDrawing", "edited", "selectionPoint", "midPoint", "closingPoint", "snappingPoint", "coordinatePoint"];
+const MODE_BY_GEOMETRY = {
+  Point: "point",
+  LineString: "linestring",
+  Polygon: "polygon"
+};
+export function committedFeatures(draw) {
+  return draw.getSnapshot().filter((feature) => !GUIDANCE_KEYS.some((key) => feature.properties[key]));
+}
+function toFeatures(geojson) {
+  if (geojson.type === "FeatureCollection") return geojson.features;
+  if (geojson.type === "Feature") return [geojson];
+  return [{ type: "Feature", properties: {}, geometry: geojson }];
+}
+export function toStoreFeatures(draw, geojson) {
+  return toFeatures(geojson).flatMap((feature) => {
+    const mode = feature.properties?.mode ?? MODE_BY_GEOMETRY[feature.geometry.type];
+    if (!mode) {
+      logger.warn(`Draw: unsupported geometry type "${feature.geometry.type}" skipped.`);
+      return [];
+    }
+    return [{
+      ...feature,
+      id: feature.id ?? draw.getFeatureId(),
+      properties: { ...feature.properties, mode }
+    }];
+  });
+}
+export function addStoreFeatures(draw, features) {
+  if (!features.length) return [];
+  return draw.addFeatures(features).flatMap((result) => {
+    if (result.valid && result.id !== void 0) return [result.id];
+    logger.warn(`Draw: feature "${String(result.id)}" rejected: ${result.reason ?? "invalid"}.`);
+    return [];
+  });
+}
+export function createDrawContext(mapId, callbacks) {
+  const draw = shallowRef();
+  let resolveReady;
+  const readyPromise = new Promise((resolve) => {
+    resolveReady = resolve;
+  });
+  function attach(instance) {
+    draw.value = instance;
+    resolveReady(instance);
+  }
+  async function withDraw(action) {
+    const instance = await readyPromise;
+    const result = action(instance);
+    callbacks.onFeatures(committedFeatures(instance));
+    return result;
+  }
+  const context = {
+    mapId,
+    draw,
+    whenReady: () => readyPromise,
+    changeMode: async (mode) => {
+      const instance = await readyPromise;
+      instance.setMode(mode);
+      callbacks.onMode(mode);
+    },
+    add: (geojson) => withDraw((instance) => addStoreFeatures(instance, toStoreFeatures(instance, geojson))),
+    deleteAll: () => withDraw((instance) => instance.clear()),
+    setFeatureProperty: (featureId, property, value) => withDraw((instance) => {
+      instance.updateFeatureProperties(featureId, { [property]: value });
+    }),
+    getAll: () => draw.value ? { type: "FeatureCollection", features: committedFeatures(draw.value) } : void 0,
+    getMode: () => draw.value?.getMode()
+  };
+  return { context, attach };
+}

package/dist/runtime/domains/map/draw-registry.d.ts

@@ -0,0 +1,5 @@
+import type { MaplibreDrawContext } from '../../types';
+export declare function registerDraw(context: MaplibreDrawContext): void;
+/** 按上下文身份注销：过渡期新控件可能先于旧控件卸载完成注册，按 id 删会误删新注册 */
+export declare function unregisterDraw(context: MaplibreDrawContext): void;
+export declare function getDrawContext(mapId: string): MaplibreDrawContext | undefined;

package/dist/runtime/domains/map/draw-registry.js

@@ -0,0 +1,15 @@
+import { shallowReactive } from "vue";
+import { logger } from "../../utils/logger.js";
+const registry = shallowReactive(/* @__PURE__ */ new Map());
+export function registerDraw(context) {
+  if (registry.has(context.mapId)) {
+    logger.warn(`map "${context.mapId}" already has a <MaplibreDrawControl>; the latest one takes over.`);
+  }
+  registry.set(context.mapId, context);
+}
+export function unregisterDraw(context) {
+  if (registry.get(context.mapId) === context) registry.delete(context.mapId);
+}
+export function getDrawContext(mapId) {
+  return registry.get(mapId);
+}

package/dist/runtime/domains/map/draw-toolbar.d.ts

@@ -0,0 +1,15 @@
+import type { IControl } from 'maplibre-gl';
+export interface DrawToolbarOptions {
+    /** 按钮对应的模式名，按顺序渲染 */
+    modes: string[];
+    /** 点击模式按钮 */
+    onMode: (mode: string) => void;
+    /** 点击删除按钮 */
+    onTrash: () => void;
+}
+export interface DrawToolbar extends IControl {
+    /** 高亮当前模式按钮 */
+    setActive: (mode: string | undefined) => void;
+}
+/** terra-draw 不带 UI，此控件提供模式切换与删除按钮，挂在地图控件槽位 */
+export declare function createDrawToolbar(options: DrawToolbarOptions): DrawToolbar;

package/dist/runtime/domains/map/draw-toolbar.js

@@ -0,0 +1,52 @@
+const ICONS = {
+  select: '<path d="M6 3l12 9-5.5 1.2L15 20l-2.4 1-2.5-6.7L6 18z"/>',
+  point: '<circle cx="12" cy="12" r="4" fill="currentColor"/>',
+  linestring: '<path d="M4 19l6-10 5 6 5-10"/>',
+  polygon: '<path d="M5 18L4 8l8-4 8 5-3 10z"/>',
+  rectangle: '<rect x="4" y="6" width="16" height="12"/>',
+  circle: '<circle cx="12" cy="12" r="8"/>',
+  ellipse: '<ellipse cx="12" cy="12" rx="9" ry="6"/>',
+  sector: '<path d="M12 12h8a8 8 0 0 0-8-8z"/>',
+  trash: '<path d="M5 7h14M10 7V5h4v2M7 7l1 13h8l1-13"/>'
+};
+const LABELS = {
+  select: "Select",
+  point: "Point",
+  linestring: "Line",
+  polygon: "Polygon",
+  rectangle: "Rectangle",
+  circle: "Circle",
+  ellipse: "Ellipse",
+  sector: "Sector",
+  trash: "Delete"
+};
+function createButton(name, dataset, onClick) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = "movk-draw-toolbar__button";
+  button.title = LABELS[name] ?? name;
+  button.setAttribute("aria-label", button.title);
+  Object.assign(button.dataset, dataset);
+  button.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linejoin="round" stroke-linecap="round">${ICONS[name] ?? ""}</svg>`;
+  button.addEventListener("click", onClick);
+  return button;
+}
+export function createDrawToolbar(options) {
+  const container = document.createElement("div");
+  container.className = "maplibregl-ctrl maplibregl-ctrl-group movk-draw-toolbar";
+  const modeButtons = options.modes.map((mode) => {
+    const button = createButton(mode, { mode }, () => options.onMode(mode));
+    container.appendChild(button);
+    return button;
+  });
+  container.appendChild(createButton("trash", { action: "trash" }, options.onTrash));
+  return {
+    onAdd: () => container,
+    onRemove: () => container.remove(),
+    setActive(mode) {
+      for (const button of modeButtons) {
+        button.setAttribute("aria-pressed", String(button.dataset.mode === mode));
+      }
+    }
+  };
+}

package/dist/runtime/domains/map/draw.d.ts

@@ -0,0 +1,4 @@
+import type { InjectionKey } from 'vue';
+import type { MaplibreDrawContext } from '../../types';
+/** MaplibreDrawControl 向子树下发绘制上下文的注入键 */
+export declare const DrawKey: InjectionKey<MaplibreDrawContext>;

package/dist/runtime/domains/map/draw.js

@@ -0,0 +1 @@
+export const DrawKey = Symbol("movk-maplibre:draw");

package/dist/runtime/domains/map/layer-group.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey, Ref } from 'vue';
+/** MaplibreLayerGroup 向子图层下发的组上下文 */
+export interface LayerGroupContext {
+    /** 组内图层缺省插入锚点（子图层自身 beforeId 优先） */
+    beforeId: Ref<string | undefined>;
+    /** 组级显隐开关 */
+    visible: Ref<boolean>;
+}
+export declare const LayerGroupKey: InjectionKey<LayerGroupContext>;

package/dist/runtime/domains/map/layer-group.js

@@ -0,0 +1 @@
+export const LayerGroupKey = Symbol("movk-maplibre:layer-group");

package/dist/runtime/domains/map/registry.d.ts

@@ -0,0 +1,4 @@
+import type { MaplibreContext } from '../../types';
+export declare function registerMap(context: MaplibreContext): void;
+export declare function unregisterMap(id: string): void;
+export declare function getMapContext(id: string): MaplibreContext | undefined;

package/dist/runtime/domains/map/registry.js

@@ -0,0 +1,10 @@
+const registry = /* @__PURE__ */ new Map();
+export function registerMap(context) {
+  registry.set(context.id, context);
+}
+export function unregisterMap(id) {
+  registry.delete(id);
+}
+export function getMapContext(id) {
+  return registry.get(id);
+}

package/dist/runtime/domains/map/resolve.d.ts

@@ -0,0 +1,7 @@
+import type { MaplibreContext } from '../../types';
+/**
+ * setup 阶段捕获注入上下文，返回延迟解析器：
+ * 显式 mapId 优先查注册表（地图挂载后可得），否则回退当前注入。
+ * 供可在 MaplibreMap 子树外使用的交互 composables 共享。
+ */
+export declare function useContextResolver(mapId?: string): () => MaplibreContext | undefined;

package/dist/runtime/domains/map/resolve.js

@@ -0,0 +1,7 @@
+import { inject } from "vue";
+import { MaplibreContextKey } from "./context.js";
+import { getMapContext } from "./registry.js";
+export function useContextResolver(mapId) {
+  const injected = inject(MaplibreContextKey, null);
+  return () => mapId ? getMapContext(mapId) : injected ?? void 0;
+}

package/dist/runtime/domains/map/style-effect.d.ts

@@ -0,0 +1,6 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+/**
+ * 样式级效果（sky 等）共享逻辑：
+ * 就绪即应用（setStyle 重载后经 onReady 自动重设），来源变化重应用，卸载时清除。
+ */
+export declare function useStyleEffect<T>(source: () => T, apply: (map: MaplibreMap, value: T) => void, clear: (map: MaplibreMap) => void): void;

package/dist/runtime/domains/map/style-effect.js

@@ -0,0 +1,21 @@
+import { onUnmounted, watch } from "vue";
+import { useMap } from "../../composables/useMap.js";
+export function useStyleEffect(source, apply, clear) {
+  const ctx = useMap();
+  function safeRun(map, action) {
+    try {
+      action(map);
+    } catch {
+    }
+  }
+  const stopReady = ctx.onReady((map) => apply(map, source()));
+  watch(source, (value) => {
+    const map = ctx.map.value;
+    if (map) safeRun(map, (m) => apply(m, value));
+  }, { deep: true });
+  onUnmounted(() => {
+    stopReady();
+    const map = ctx.map.value;
+    if (map) safeRun(map, clear);
+  });
+}

package/dist/runtime/draw-modes/index.d.ts

@@ -0,0 +1,16 @@
+import type { TerraDrawExtend } from 'terra-draw';
+import type { DrawThemeOptions } from '../utils/draw-theme';
+/** 内置绘制模式名（不含选择模式 'select'） */
+export declare const DRAW_MODE_NAMES: readonly ["point", "linestring", "polygon", "rectangle", "circle", "ellipse", "sector"];
+export type DrawModeName = (typeof DRAW_MODE_NAMES)[number];
+/** terra-draw 模式实例（绘制或选择模式） */
+export type DrawMode = TerraDrawExtend.TerraDrawBaseDrawMode<TerraDrawExtend.CustomStyling>;
+export interface MovkDrawModesOptions {
+    /** 绘制主题，参见 drawThemeStyles */
+    theme?: DrawThemeOptions;
+}
+/**
+ * 预设 terra-draw 模式集合：选择模式 + 全部内置绘制模式，统一应用主题。
+ * 每次调用返回新实例，模式实例不可在多个 TerraDraw 间共享。
+ */
+export declare function movkDrawModes(options?: MovkDrawModesOptions): DrawMode[];

package/dist/runtime/draw-modes/index.js

@@ -0,0 +1,32 @@
+import {
+  TerraDrawCircleMode,
+  TerraDrawEllipseMode,
+  TerraDrawLineStringMode,
+  TerraDrawPointMode,
+  TerraDrawPolygonMode,
+  TerraDrawRectangleMode,
+  TerraDrawSectorMode,
+  TerraDrawSelectMode
+} from "terra-draw";
+import { drawThemeStyles } from "../utils/draw-theme.js";
+export const DRAW_MODE_NAMES = ["point", "linestring", "polygon", "rectangle", "circle", "ellipse", "sector"];
+const EDITABLE_COORDINATES = { draggable: true, deletable: true, midpoints: true };
+export function movkDrawModes(options = {}) {
+  const styles = drawThemeStyles(options.theme);
+  const flags = Object.fromEntries(DRAW_MODE_NAMES.map((name) => [name, {
+    feature: {
+      draggable: true,
+      ...name === "linestring" || name === "polygon" ? { coordinates: EDITABLE_COORDINATES } : {}
+    }
+  }]));
+  return [
+    new TerraDrawSelectMode({ flags, styles: styles.select }),
+    new TerraDrawPointMode({ styles: styles.point }),
+    new TerraDrawLineStringMode({ styles: styles.linestring }),
+    new TerraDrawPolygonMode({ styles: styles.polygon }),
+    new TerraDrawRectangleMode({ styles: styles.rectangle }),
+    new TerraDrawCircleMode({ styles: styles.circle }),
+    new TerraDrawEllipseMode({ styles: styles.ellipse }),
+    new TerraDrawSectorMode({ styles: styles.sector })
+  ];
+}

package/dist/runtime/index.css

@@ -0,0 +1 @@
+@import "maplibre-gl/dist/maplibre-gl.css";