@movk/maplibre 1.0.0 → 1.1.0

package/dist/runtime/utils/frame-icon.js

@@ -14,18 +14,24 @@ export function pickFrameIndex(elapsedMs, durations, fps, total) {
 }
 export function createFrameStyleImage(options) {
   const { size, frames, getMap } = options;
-  const fps = options.fps ?? 12;
+  const byteLength = size * size * 4;
   let start = 0;
   let lastIndex = -1;
   let committed = false;
+  let current;
   const image = {
     width: size,
     height: size,
-    data: new Uint8Array(size * size * 4),
+    data: new Uint8Array(byteLength),
     render() {
       const fs = frames();
+      if (fs !== current) {
+        current = fs;
+        start = 0;
+        lastIndex = -1;
+      }
       const total = fs.length;
-      if (!total) {
+      if (!total || fs[0].data.length !== byteLength) {
         if (committed) return false;
         committed = true;
         return true;
@@ -34,7 +40,7 @@ export function createFrameStyleImage(options) {
       if (map) map.triggerRepaint();
       committed = true;
       if (!start) start = performance.now();
-      const index = pickFrameIndex(performance.now() - start, options.durations?.(), fps, total);
+      const index = pickFrameIndex(performance.now() - start, options.durations?.(), options.fps?.() ?? 12, total);
       if (index === lastIndex) return false;
       lastIndex = index;
       image.data = fs[index].data;

package/dist/runtime/utils/graticule.d.ts

@@ -0,0 +1,19 @@
+import type { FeatureCollection, LineString, Point, Position } from 'geojson';
+/** 经纬度范围 [west, south, east, north] */
+export type Bounds = [number, number, number, number];
+type Axis = 'lon' | 'lat';
+/** 按缩放级别选择步长，使 512px 视口宽度内约有 4 条以上经线 */
+export declare function graticuleStep(zoom: number): number;
+/** 度数标注，如 `30°N`、`120°E`、`0°`；经度归一化到 (-180, 180] */
+export declare function formatDegree(value: number, axis: Axis): string;
+/** 生成外扩范围内的经线与纬线（均已加密），并返回该范围供判断是否需要重算 */
+export declare function graticuleLines(bounds: Bounds, step: number): {
+    extent: Bounds;
+    data: FeatureCollection<LineString>;
+};
+/**
+ * 生成视口内的度数标注：经线标注位于 anchor 纬度，纬线标注位于 anchor 经度；
+ * anchor 缺省为视口西南角（沿南、西边缘排布），世界视图可传地图中心
+ */
+export declare function graticuleLabels([west, south, east, north]: Bounds, step: number, anchor?: Position): FeatureCollection<Point>;
+export {};

package/dist/runtime/utils/graticule.js

@@ -0,0 +1,62 @@
+const STEPS = [30, 10, 5, 2, 1, 0.5, 0.25, 0.1];
+const MIN_LINES = 4;
+const MAX_LAT = 85;
+const DENSIFY = 1;
+const round = (value) => Math.round(value * 1e6) / 1e6;
+function snap(value, fn) {
+  const nearest = Math.round(value);
+  return Math.abs(value - nearest) < 1e-9 ? nearest : fn(value);
+}
+export function graticuleStep(zoom) {
+  const span = 360 / 2 ** zoom;
+  return STEPS.find((step) => span / step >= MIN_LINES) ?? STEPS.at(-1);
+}
+export function formatDegree(value, axis) {
+  const normalized = axis === "lon" ? value - 360 * Math.ceil((value - 180) / 360) : value;
+  const abs = round(Math.abs(normalized));
+  if (abs === 0 || axis === "lon" && abs === 180) return `${abs}\xB0`;
+  const hemisphere = axis === "lon" ? normalized > 0 ? "E" : "W" : normalized > 0 ? "N" : "S";
+  return `${abs}\xB0${hemisphere}`;
+}
+function multiples(from, to, step) {
+  const first = snap(from / step, Math.ceil);
+  const last = snap(to / step, Math.floor);
+  return Array.from({ length: Math.max(0, last - first + 1) }, (_, i) => round((first + i) * step));
+}
+function densify(from, to, interval) {
+  const count = Math.max(1, Math.ceil(round((to - from) / interval)));
+  return Array.from({ length: count + 1 }, (_, i) => round(Math.min(to, from + i * interval)));
+}
+function expand([west, south, east, north], step) {
+  const fullLon = west < -180 || east > 180;
+  return [
+    fullLon ? -180 : Math.max(-180, round((snap(west / step, Math.floor) - 1) * step)),
+    Math.max(-MAX_LAT, round((snap(south / step, Math.floor) - 1) * step)),
+    fullLon ? 180 : Math.min(180, round((snap(east / step, Math.ceil) + 1) * step)),
+    Math.min(MAX_LAT, round((snap(north / step, Math.ceil) + 1) * step))
+  ];
+}
+function line(coordinates, axis, value) {
+  return { type: "Feature", properties: { axis, value }, geometry: { type: "LineString", coordinates } };
+}
+export function graticuleLines(bounds, step) {
+  const extent = expand(bounds, step);
+  const [west, south, east, north] = extent;
+  const interval = Math.min(step, DENSIFY);
+  const lats = densify(south, north, interval);
+  const lons = densify(west, east, interval);
+  const meridianValues = multiples(west, east, step).filter((lon) => !(east - west >= 360 && lon === 180));
+  const meridians = meridianValues.map((lon) => line(lats.map((lat) => [lon, lat]), "lon", lon));
+  const parallels = multiples(south, north, step).map((lat) => line(lons.map((lon) => [lon, lat]), "lat", lat));
+  return { extent, data: { type: "FeatureCollection", features: [...meridians, ...parallels] } };
+}
+function label(coordinates, axis, value) {
+  return { type: "Feature", properties: { axis, label: formatDegree(value, axis) }, geometry: { type: "Point", coordinates } };
+}
+export function graticuleLabels([west, south, east, north], step, anchor = [west, south]) {
+  const [anchorLon = west, anchorLat = south] = anchor;
+  const lonValues = multiples(west, east, step).filter((lon2) => !(east - west >= 360 && lon2 === 180));
+  const lon = lonValues.map((value) => label([value, anchorLat], "lon", value));
+  const lat = multiples(Math.max(south, -MAX_LAT), Math.min(north, MAX_LAT), step).map((value) => label([anchorLon, value], "lat", value));
+  return { type: "FeatureCollection", features: [...lon, ...lat] };
+}

package/dist/runtime/utils/layer-opacity.d.ts

@@ -0,0 +1,7 @@
+import type { LayerSpecification } from '@maplibre/maplibre-gl-style-spec';
+type LayerType = LayerSpecification['type'];
+/** 图层类型对应的透明度属性 */
+export declare function opacityPropsFor(type: LayerType): readonly string[];
+/** 透明度按系数缩放；系数为 1 时原样返回，未设置视为默认值 1 */
+export declare function scaleOpacity(value: unknown, factor: number): unknown;
+export {};

package/dist/runtime/utils/layer-opacity.js

@@ -0,0 +1,59 @@
+import { logger } from "./logger.js";
+const OPACITY_PROPS = {
+  "fill": ["fill-opacity"],
+  "line": ["line-opacity"],
+  "circle": ["circle-opacity", "circle-stroke-opacity"],
+  "symbol": ["icon-opacity", "text-opacity"],
+  "raster": ["raster-opacity"],
+  "fill-extrusion": ["fill-extrusion-opacity"],
+  "heatmap": ["heatmap-opacity"],
+  "background": ["background-opacity"]
+};
+export function opacityPropsFor(type) {
+  return OPACITY_PROPS[type] ?? [];
+}
+function containsZoom(value) {
+  if (!Array.isArray(value)) return false;
+  if (value[0] === "zoom" && value.length === 1) return true;
+  return value.some(containsZoom);
+}
+function isZoomInput(value) {
+  return Array.isArray(value) && value[0] === "zoom" && value.length === 1;
+}
+function scaleOutput(value, factor) {
+  if (typeof value === "number") return value * factor;
+  if (containsZoom(value)) return void 0;
+  return ["*", value, factor];
+}
+function scaleZoomCurve(expr, factor) {
+  const [op] = expr;
+  const outputStart = op === "interpolate" ? 4 : 2;
+  const scaled = [...expr];
+  for (let i = outputStart; i < expr.length; i += 2) {
+    const next = scaleOutput(expr[i], factor);
+    if (next === void 0) return void 0;
+    scaled[i] = next;
+  }
+  return scaled;
+}
+let warned = false;
+export function scaleOpacity(value, factor) {
+  if (factor === 1) return value;
+  if (value === void 0) return factor;
+  if (typeof value === "number") return value * factor;
+  if (Array.isArray(value)) {
+    const [op] = value;
+    const input = op === "interpolate" ? value[2] : op === "step" ? value[1] : void 0;
+    if (isZoomInput(input)) {
+      const scaled = scaleZoomCurve(value, factor);
+      if (scaled) return scaled;
+    } else if (!containsZoom(value)) {
+      return ["*", value, factor];
+    }
+  }
+  if (!warned) {
+    warned = true;
+    logger.warn("Opacity expression cannot be scaled safely (zoom used outside a top-level interpolate/step); layer group opacity is ignored for it.", value);
+  }
+  return value;
+}

package/dist/runtime/utils/layer.js

@@ -1,6 +1,7 @@
 import { equalsBy } from "@movk/core";
 function applyChangedProps(next, prev, apply) {
-  for (const key of Object.keys(next)) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
+  for (const key of keys) {
     if (!equalsBy(next[key], prev[key])) apply(key, next[key]);
   }
 }

package/dist/runtime/utils/legend.d.ts

@@ -0,0 +1,9 @@
+import type { LayerSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { LegendItem } from '../types/layer';
+/** 参与图例推导的图层描述 */
+export interface LegendLayer {
+    type: LayerSpecification['type'];
+    paint?: Record<string, unknown>;
+}
+/** 由图层颜色推导图例项：支持字面量、match、step、interpolate，同组内去重 */
+export declare function deriveLegend(layers: LegendLayer[], title: string): LegendItem[];

package/dist/runtime/utils/legend.js

@@ -0,0 +1,52 @@
+const COLOR_PROPS = {
+  "fill": ["fill-color", "fill"],
+  "line": ["line-color", "line"],
+  "circle": ["circle-color", "circle"],
+  "fill-extrusion": ["fill-extrusion-color", "fill"]
+};
+const isZoomInput = (value) => Array.isArray(value) && value[0] === "zoom";
+function fromMatch(expr, type) {
+  const items = [];
+  for (let i = 2; i + 1 < expr.length; i += 2) {
+    const [label, color] = [expr[i], expr[i + 1]];
+    if (typeof color !== "string") continue;
+    items.push({ label: Array.isArray(label) ? label.join(", ") : String(label), type, color });
+  }
+  return items;
+}
+function fromStep(expr, type) {
+  const colors = expr.filter((_, i) => i >= 2 && i % 2 === 0);
+  const stops = expr.filter((_, i) => i >= 3 && i % 2 === 1);
+  if (colors.some((color) => typeof color !== "string")) return [];
+  return colors.map((color, i) => {
+    const label = i === 0 ? `< ${stops[0]}` : i === stops.length ? `\u2265 ${stops[i - 1]}` : `${stops[i - 1]} \u2013 ${stops[i]}`;
+    return { label, type, color };
+  });
+}
+function fromInterpolate(expr) {
+  const stops = expr.filter((_, i) => i >= 3 && i % 2 === 1);
+  const colors = expr.filter((_, i) => i >= 4 && i % 2 === 0);
+  if (!colors.length || colors.some((color) => typeof color !== "string")) return [];
+  return [{ label: `${stops[0]} \u2013 ${stops.at(-1)}`, type: "gradient", colors }];
+}
+function itemsFor(value, type, title) {
+  if (typeof value === "string") return [{ label: title, type, color: value }];
+  if (!Array.isArray(value)) return [];
+  const [op] = value;
+  if (op === "match") return fromMatch(value, type);
+  if (op === "step" && !isZoomInput(value[1])) return fromStep(value, type);
+  if (op === "interpolate" && !isZoomInput(value[2])) return fromInterpolate(value);
+  return [];
+}
+export function deriveLegend(layers, title) {
+  const seen = /* @__PURE__ */ new Set();
+  return layers.flatMap((layer) => {
+    const entry = COLOR_PROPS[layer.type];
+    return entry ? itemsFor(layer.paint?.[entry[0]], entry[1], title) : [];
+  }).filter((item) => {
+    const key = JSON.stringify(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/dist/runtime/utils/marker.d.ts

@@ -0,0 +1,11 @@
+import type { Marker, MarkerOptions } from 'maplibre-gl';
+export type MarkerInputOptions = Omit<MarkerOptions, 'element'>;
+/**
+ * 判断选项变化是否需要重建 marker：anchor/color/scale 无 setter，
+ * offset 移除后的缺省值取决于是否默认水滴 pin，交由构造函数决定。
+ */
+export declare function markerNeedsRebuild(next: MarkerInputOptions, prev: MarkerInputOptions): boolean;
+/** 移除 className 选项加到 marker 元素上的类（重建复用插槽元素前清理残留） */
+export declare function removeMarkerClassName(marker: Marker, className?: string): void;
+/** 以 setter 增量下发有差异的选项，调用方需先经 markerNeedsRebuild 排除无 setter 的字段 */
+export declare function applyMarkerOptions(marker: Marker, next: MarkerInputOptions, prev: MarkerInputOptions): void;

package/dist/runtime/utils/marker.js

@@ -0,0 +1,28 @@
+import { isDeepEqual } from "@movk/core";
+function classNames(value) {
+  return value?.split(" ").filter(Boolean) ?? [];
+}
+export function markerNeedsRebuild(next, prev) {
+  return next.anchor !== prev.anchor || next.color !== prev.color || next.scale !== prev.scale || next.offset === void 0 && prev.offset !== void 0;
+}
+export function removeMarkerClassName(marker, className) {
+  for (const name of classNames(className)) marker.removeClassName(name);
+}
+export function applyMarkerOptions(marker, next, prev) {
+  if (next.draggable !== prev.draggable) marker.setDraggable(next.draggable);
+  if (next.rotation !== prev.rotation) marker.setRotation(next.rotation);
+  if (next.rotationAlignment !== prev.rotationAlignment || next.pitchAlignment !== prev.pitchAlignment) {
+    marker.setRotationAlignment(next.rotationAlignment);
+    marker.setPitchAlignment(next.pitchAlignment);
+  }
+  if (next.offset !== void 0 && !isDeepEqual(next.offset, prev.offset)) marker.setOffset(next.offset);
+  if (next.opacity !== prev.opacity || next.opacityWhenCovered !== prev.opacityWhenCovered) {
+    marker.setOpacity();
+    marker.setOpacity(next.opacity, next.opacityWhenCovered);
+  }
+  if (next.subpixelPositioning !== prev.subpixelPositioning) marker.setSubpixelPositioning(next.subpixelPositioning ?? false);
+  if (next.className !== prev.className) {
+    removeMarkerClassName(marker, prev.className);
+    for (const name of classNames(next.className)) marker.addClassName(name);
+  }
+}

package/dist/runtime/utils/mask.d.ts

@@ -0,0 +1,8 @@
+import type { Feature, FeatureCollection, MultiPolygon, Polygon } from 'geojson';
+/** 遮罩输入：面状几何、要素或要素集合；非面状要素被忽略 */
+export type MaskInput = Polygon | MultiPolygon | Feature | FeatureCollection;
+/**
+ * 生成反向遮罩：以全球范围为外环，把目标区域各多边形的外环作为孔洞。
+ * 目标自身的孔洞（飞地）不参与；无面状要素时返回空集合。
+ */
+export declare function maskPolygon(data: MaskInput): Feature<Polygon> | FeatureCollection;

package/dist/runtime/utils/mask.js

@@ -0,0 +1,33 @@
+const MAX_LAT = 85.0511;
+const WORLD_RING = [[-180, -MAX_LAT], [180, -MAX_LAT], [180, MAX_LAT], [-180, MAX_LAT], [-180, -MAX_LAT]];
+function signedArea(ring) {
+  let sum = 0;
+  for (let i = 0; i < ring.length - 1; i++) {
+    const [x1 = 0, y1 = 0] = ring[i];
+    const [x2 = 0, y2 = 0] = ring[i + 1];
+    sum += x1 * y2 - x2 * y1;
+  }
+  return sum / 2;
+}
+function toClockwise(ring) {
+  return signedArea(ring) > 0 ? [...ring].reverse() : ring;
+}
+function outerRings(geometry) {
+  if (geometry?.type === "Polygon") return geometry.coordinates.slice(0, 1);
+  if (geometry?.type === "MultiPolygon") return geometry.coordinates.map((polygon) => polygon[0]).filter(Boolean);
+  return [];
+}
+function collectRings(data) {
+  if (data.type === "FeatureCollection") return data.features.flatMap((feature) => outerRings(feature.geometry));
+  if (data.type === "Feature") return outerRings(data.geometry);
+  return outerRings(data);
+}
+export function maskPolygon(data) {
+  const holes = collectRings(data).filter((ring) => ring.length >= 4).map(toClockwise);
+  if (!holes.length) return { type: "FeatureCollection", features: [] };
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: { type: "Polygon", coordinates: [WORLD_RING, ...holes] }
+  };
+}

package/dist/runtime/utils/minimap.d.ts

@@ -0,0 +1,6 @@
+import type { Feature, Polygon } from 'geojson';
+import type { Map as MaplibreMap } from 'maplibre-gl';
+/** 鹰眼缩放级别：主图缩放叠加偏移，不低于 0 */
+export declare function minimapZoom(parentZoom: number, offset: number): number;
+/** 主图视口多边形：容器四角反投影，旋转、倾斜时同样贴合可视范围 */
+export declare function viewportPolygon(map: Pick<MaplibreMap, 'getContainer' | 'unproject'>): Feature<Polygon>;

package/dist/runtime/utils/minimap.js

@@ -0,0 +1,15 @@
+export function minimapZoom(parentZoom, offset) {
+  return Math.max(parentZoom + offset, 0);
+}
+export function viewportPolygon(map) {
+  const { clientWidth: w, clientHeight: h } = map.getContainer();
+  const ring = [[0, 0], [w, 0], [w, h], [0, h]].map(([x, y]) => {
+    const { lng, lat } = map.unproject([x, y]);
+    return [lng, lat];
+  });
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: { type: "Polygon", coordinates: [[...ring, ring[0]]] }
+  };
+}

package/dist/runtime/utils/pmtiles.d.ts

@@ -0,0 +1,3 @@
+import { Protocol } from 'pmtiles';
+/** 注册 `pmtiles://` 协议（全局单例、幂等）；返回 Protocol 实例，可经 `protocol.add(new PMTiles(...))` 登记自定义来源 */
+export declare function registerPmtilesProtocol(options?: ConstructorParameters<typeof Protocol>[0]): Protocol;

package/dist/runtime/utils/pmtiles.js

@@ -0,0 +1,10 @@
+import { addProtocol } from "maplibre-gl";
+import { Protocol } from "pmtiles";
+import { defineGlobalSingleton } from "@movk/core";
+export function registerPmtilesProtocol(options) {
+  return defineGlobalSingleton("movk-maplibre:protocol:pmtiles", () => {
+    const protocol = new Protocol(options);
+    addProtocol("pmtiles", protocol.tile);
+    return protocol;
+  });
+}

package/dist/runtime/utils/source.d.ts

@@ -0,0 +1,7 @@
+import type { Source } from 'maplibre-gl';
+import type { SourceSpecification } from '@maplibre/maplibre-gl-style-spec';
+/**
+ * 按类型把 source 定义的变化增量应用到已有源，避免整源重建。
+ * prev 与 next 为同一引用（原地修改）时仅按 next 下发数据；类型变化无法原地更新，告警后跳过。
+ */
+export declare function updateSource(source: Source, next: SourceSpecification, prev?: SourceSpecification): void;

package/dist/runtime/utils/source.js

@@ -0,0 +1,35 @@
+import { omitUndefined } from "@movk/core";
+import { logger } from "./logger.js";
+const CLUSTER_KEYS = ["cluster", "clusterRadius", "clusterMaxZoom"];
+function clusterChanged(next, prev) {
+  if (!prev || prev === next) return false;
+  const previous = prev;
+  return CLUSTER_KEYS.some((key) => next[key] !== previous[key]);
+}
+export function updateSource(source, next, prev) {
+  if (prev && prev.type !== next.type) {
+    logger.warn(`Source type changed from "${prev.type}" to "${next.type}"; recreate it with a new :key instead.`);
+    return;
+  }
+  if (next.type === "geojson") {
+    const geojson = source;
+    if (next.data) geojson.setData(next.data);
+    if (clusterChanged(next, prev)) {
+      geojson.setClusterOptions(omitUndefined({
+        cluster: next.cluster,
+        clusterRadius: next.clusterRadius,
+        clusterMaxZoom: next.clusterMaxZoom
+      })).catch((error) => logger.error("Failed to update cluster options:", error));
+    }
+  } else if (next.type === "vector") {
+    if (next.url) source.setUrl(next.url);
+    if (next.tiles) source.setTiles(next.tiles);
+  } else if (next.type === "raster" || next.type === "raster-dem") {
+    if (next.url) source.setUrl(next.url);
+    if (next.tiles) source.setTiles(next.tiles);
+  } else if (next.type === "image" && next.url) {
+    source.updateImage(next);
+  } else if (next.type === "video" && next.coordinates) {
+    source.setCoordinates(next.coordinates);
+  }
+}

package/dist/runtime/utils/swipe.d.ts

@@ -0,0 +1,32 @@
+/** 卷帘分隔方向：vertical 为竖直分隔条左右对比，horizontal 为水平分隔条上下对比 */
+export type SwipeOrientation = 'vertical' | 'horizontal';
+interface Point {
+    x: number;
+    y: number;
+}
+interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/** 对照图裁切：只露出分隔条之后（右侧或下侧）的部分 */
+export declare function swipeClipPath(position: number, orientation: SwipeOrientation): string;
+/** 指针坐标换算为分隔条在容器内的比例（0..1） */
+export declare function positionFromPointer(rect: Rect, point: Point, orientation: SwipeOrientation): number;
+/** 容器内的点是否落在对照图露出区域（分隔条上视为露出） */
+export declare function isPointRevealed(point: Point, size: {
+    width: number;
+    height: number;
+}, position: number, orientation: SwipeOrientation): boolean;
+interface AttributionSource {
+    getStyle: () => {
+        sources?: object;
+    } | undefined;
+    getSource: (id: string) => {
+        attribution?: string;
+    } | undefined;
+}
+/** 汇总地图各来源的署名，按来源顺序去重 */
+export declare function collectAttributions(map: AttributionSource): string[];
+export {};

package/dist/runtime/utils/swipe.js

@@ -0,0 +1,18 @@
+import { clamp } from "@movk/core";
+export function swipeClipPath(position, orientation) {
+  const percent = `${clamp(position, 0, 1) * 100}%`;
+  return orientation === "vertical" ? `inset(0 0 0 ${percent})` : `inset(${percent} 0 0 0)`;
+}
+export function positionFromPointer(rect, point, orientation) {
+  const [offset, size] = orientation === "vertical" ? [point.x - rect.left, rect.width] : [point.y - rect.top, rect.height];
+  return size > 0 ? clamp(offset / size, 0, 1) : 0;
+}
+export function isPointRevealed(point, size, position, orientation) {
+  const ratio = clamp(position, 0, 1);
+  return orientation === "vertical" ? point.x >= ratio * size.width : point.y >= ratio * size.height;
+}
+export function collectAttributions(map) {
+  const ids = Object.keys(map.getStyle()?.sources ?? {});
+  const texts = ids.map((id) => map.getSource(id)?.attribution?.trim()).filter((text) => Boolean(text));
+  return [...new Set(texts)];
+}

package/dist/runtime/utils/tianditu.d.ts

@@ -1,4 +1,4 @@
-import type { RasterSourceSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { RasterSourceSpecification, StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
 /** 天地图图层类型：vec 矢量底图、img 影像底图、ter 地形、cva 矢量注记、cia 影像注记、cta 地形注记 */
 export type TiandituLayerType = 'vec' | 'img' | 'ter' | 'cva' | 'cia' | 'cta';
 /** 取底图对应的注记图层类型；注记类型自身或无对应时返回 undefined。 */
@@ -19,3 +19,12 @@ export interface TiandituSourceOptions {
 }
 /** 生成天地图球面墨卡托（EPSG:3857）栅格数据源规格，可直接用于 MaplibreSource。 */
 export declare function tiandituRasterSource(layer: TiandituLayerType, options?: TiandituSourceOptions): RasterSourceSpecification;
+export interface TiandituStyleOptions extends TiandituSourceOptions {
+    /** 叠加对应注记图层（vec→cva / img→cia / ter→cta） */
+    annotation?: boolean;
+}
+/**
+ * 生成以天地图为底图的完整样式，可直接作为 MaplibreMap 的 options.style 或底图切换项，
+ * 与矢量样式经同一 setStyle 机制切换；glyphs 取自运行时配置，便于叠加文字图层。
+ */
+export declare function tiandituStyle(layer: TiandituLayerType, options?: TiandituStyleOptions): StyleSpecification;

package/dist/runtime/utils/tianditu.js

@@ -1,4 +1,5 @@
 import { getMaplibreConfig } from "../domains/map/config.js";
+import { blankStyle } from "../domains/map/style.js";
 import { logger } from "./logger.js";
 import { wmtsRasterSource } from "./wmts.js";
 const ANNOTATION_MAP = {
@@ -24,3 +25,13 @@ export function tiandituRasterSource(layer, options = {}) {
     params: { tk: tk ?? "" }
   });
 }
+export function tiandituStyle(layer, options = {}) {
+  const { annotation, ...sourceOptions } = options;
+  const types = [layer, annotation ? tiandituAnnotationFor(layer) : void 0].filter((type) => type !== void 0);
+  const style = blankStyle();
+  return {
+    ...style,
+    sources: Object.fromEntries(types.map((type) => [`tianditu-${type}`, tiandituRasterSource(type, sourceOptions)])),
+    layers: types.map((type) => ({ id: `tianditu-${type}`, type: "raster", source: `tianditu-${type}` }))
+  };
+}

package/dist/unplugin.d.mts

@@ -19,7 +19,7 @@ declare function maplibreComponentResolver(options?: MaplibreResolverOptions): {
         from: string;
     } | undefined;
 };
-/** 本库 composables + 工具的自动导入项，注入既有 unplugin-auto-import 实例复用 */
+/** 本库 composables 的自动导入项，注入既有 unplugin-auto-import 实例复用 */
 declare function maplibreAutoImports(): {
     from: string;
     imports: string[];

package/dist/unplugin.d.ts

@@ -19,7 +19,7 @@ declare function maplibreComponentResolver(options?: MaplibreResolverOptions): {
         from: string;
     } | undefined;
 };
-/** 本库 composables + 工具的自动导入项，注入既有 unplugin-auto-import 实例复用 */
+/** 本库 composables 的自动导入项，注入既有 unplugin-auto-import 实例复用 */
 declare function maplibreAutoImports(): {
     from: string;
     imports: string[];

package/dist/unplugin.mjs

@@ -6,10 +6,6 @@ import Components from 'unplugin-vue-components';
 import AutoImport from 'unplugin-auto-import';
 
 const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
-const UTIL_MANIFEST = {
-  movkDrawModes: "draw-modes",
-  drawThemeStyles: "utils/draw-theme"
-};
 function componentMap() {
   const dir = join(runtimeDir, "components");
   const map = /* @__PURE__ */ new Map();
@@ -33,9 +29,7 @@ function maplibreComponentResolver(options = {}) {
 }
 function maplibreAutoImports() {
   const cdir = join(runtimeDir, "composables");
-  const composables = readdirSync(cdir).filter((f) => f.endsWith(".ts")).map((f) => f.slice(0, -".ts".length)).map((name) => ({ from: join(cdir, name), imports: [name] }));
-  const utils = Object.entries(UTIL_MANIFEST).map(([name, file]) => ({ from: join(runtimeDir, file), imports: [name] }));
-  return [...composables, ...utils];
+  return readdirSync(cdir).filter((f) => f.endsWith(".ts")).map((f) => f.slice(0, -".ts".length)).map((name) => ({ from: join(cdir, name), imports: [name] }));
 }
 const MaplibreUnplugin = createUnplugin((options = {}, meta) => {
   const dts = options.dts ?? true;