gis-view-webgl2 0.1.7 → 0.1.8

package/docs/steps/selftest-perf.html

@@ -319,9 +319,36 @@
 				big.removePoints(['bench-new', 'bench-new2'])
 				const channelRemoveMs = now() - channelRemoveStarted
 				diag('通道在场时补 2 个点', `${channelAddMs.toFixed(1)} ms（这一轮之前 40 ms 上下）`)
-				diag('通道在场时删这 2 个点', `${channelRemoveMs.toFixed(1)} ms（这一轮之前 35 ms 上下）`)
-				check('通道在场时的增删：通道成员表不动、点真的加上又删掉', big.getData().points.length === pointCount && big.getChannel('bench-ch').lineIndexes.length === 2, JSON.stringify({ points: big.getData().points.length, members: big.getChannel('bench-ch').lineIndexes }))
-				big.updateOptions({ channels: [] })
+				diag('通道在场时删这 2 个点', `${channelRemoveMs.toFixed(1)} ms（这一轮之前 35 ms 上下）`)
+				check('通道在场时的增删：通道成员表不动、点真的加上又删掉', big.getData().points.length === pointCount && big.getChannel('bench-ch').lineIndexes.length === 2, JSON.stringify({ points: big.getData().points.length, members: big.getChannel('bench-ch').lineIndexes }))
+				// addLine 是末尾补线：已有通道声明时也走追加式补线，不能为了加一条独立线路把整份场景重排。
+				// 这里同时盯正确性（新线进场景、通道声明一条不动）与代价（最快一次明显低于整份重排）。
+				const appendLineChannelsBefore = JSON.stringify(big.getOptions().channels)
+				big.setCamera({ center: [10, 0], scale: 2 })
+				const appendLineIds = []
+				let appendLineFastestMs = Infinity
+				const appendLineStarted = now()
+				for (let index = 0; index < 5; index += 1) {
+					const callStarted = now()
+					const appendedLine = big.addLine({ from: 'p0', to: 'p1', id: `bench-added-line-${index}`, lineProps: { color: '#ff3300', width: 2 } })
+					appendLineFastestMs = Math.min(appendLineFastestMs, now() - callStarted)
+					if (appendedLine.ok) {
+						appendLineIds.push(appendedLine.lineId)
+					}
+				}
+				const appendLineMs = (now() - appendLineStarted) / 5
+				const appendLineScene = big.snapshotScene({ background: false })
+				const appendLinePainted = appendLineScene.lines.filter(line => line.color === 'rgba(255,51,0,1)').length
+				const appendLineRefreshStarted = now()
+				big.refresh()
+				const appendLineRefreshMs = now() - appendLineRefreshStarted
+				check('通道声明在场时 addLine 走追加式补线：5 条都进场景、通道声明不动', appendLineIds.length === 5 && appendLinePainted === 5 && JSON.stringify(big.getOptions().channels) === appendLineChannelsBefore, JSON.stringify({ ids: appendLineIds, painted: appendLinePainted }))
+				check('addLine 的追加代价明显低于整份重排（有通道声明也不会回落整份重建）', appendLineFastestMs * 5 < appendLineRefreshMs, `最快一次 ${appendLineFastestMs.toFixed(2)} ms · 平均 ${appendLineMs.toFixed(2)} ms vs 整份重排 ${appendLineRefreshMs.toFixed(1)} ms`)
+				diag('通道在场时 addLine 追加 1 条', `${appendLineMs.toFixed(2)} ms / 次（最快一次 ${appendLineFastestMs.toFixed(2)} ms）· 同一场景整份重排 ${appendLineRefreshMs.toFixed(1)} ms`)
+				for (const id of appendLineIds) {
+					big.removeLine(id)
+				}
+				big.updateOptions({ channels: [] })
 
 				/* ---------------- 分区（分块）渲染值不值得：视口变化时一帧的成本怎么变 ---------------- */
 				// 「把地图拆成一块一块、只画视口里的块」省的是「视口外那些实例的顶点变换」。
@@ -2323,7 +2350,7 @@
 				await sleep(30)
 				const selectedAfter = clusterView.getSelections().map(entry => entry.item?.id ?? entry.index).join(',')
 				check('点聚合：点击聚合只发 clusterClick，不发普通 click，选中集不变',
-					clusterEvents === 1 && plainEvents === 0 && selectedAfter === selectedBefore && lastClusterPayload?.action?.type === 'clusterClick' && lastClusterPayload?.action?.data?.type === 'cluster',
+					clusterEvents === 1 && plainEvents === 0 && selectedAfter === selectedBefore && lastClusterPayload?.action?.type === 'clusterClick' && lastClusterPayload?.type === 'cluster' && lastClusterPayload?.count > 1 && Array.isArray(lastClusterPayload?.pointIds) && lastClusterPayload?.action?.data === undefined && lastClusterPayload?.originalEvent instanceof Event,
 					`clusterClick=${clusterEvents} click=${plainEvents} 选中 ${selectedBefore} → ${selectedAfter} action=${lastClusterPayload?.action?.type} clickPick=${clickPick?.type ?? 'null'} clickScreen=${clickScreen.map(value => value.toFixed(1)).join(',')} client=${clickClient.map(value => value.toFixed(1)).join(',')}`)
 				const fitScale = clusterView.getCamera().scale
 				// 聚合成员在相机运动期会推迟重算；这一档没有线、又显式关掉非 MSAA 后备缓冲，

package/docs/steps/selftest-select.html

@@ -497,14 +497,19 @@
 				check('onPointerDown / onPointerUp / onClick(通道回线)：每个鼠标载荷都带 groups 与当前 group',
 					[gpDowns.at(-1), gpUps.at(-1), gpClicks.at(-1)].every(payload => payload?.groups?.length === 2 && String(payload.group?.id) === String(payload.groupId) && payload.action?.target === 'channel'),
 					JSON.stringify({ down: gpDowns.at(-1)?.groups?.length, up: gpUps.at(-1)?.groups?.length, click: gpClicks.at(-1)?.groups?.length }))
+				const gpLineChannelFields = ['channelId', 'channelIndex', 'channel', 'groupId', 'groupIndex', 'group', 'groups', 'lineIndexes', 'lineIds', 'channelContexts']
+				const gpSelectedLineIndexes = payload => (payload?.items ?? []).filter(item => item.type === 'line').map(item => item.index).join(',')
+				const gpSelectedLineIds = payload => (payload?.items ?? []).filter(item => item.type === 'line').map(item => item.item?.id).join(',')
 				const gpChannelPayloadOK = payload => String(payload?.channelId) === 'gp-ch' &&
 					payload?.groups?.length === 2 &&
 					payload?.channelContexts === undefined &&
 					String(payload.group?.id) === String(payload.groupId) &&
-					payload.items?.every(item => item.type !== 'line' || (item.channelId === payload.channelId && item.channelIndex === payload.channelIndex && item.groupId !== undefined && item.groupIndex !== undefined && item.group === undefined && item.groups === undefined))
-				check('onSelect / onSelectChange(通道回线)：单通道只摊平在顶层，items 只留标量归属且不重复挂 group / groups',
+					payload.lineIndexes?.join(',') === gpSelectedLineIndexes(payload) &&
+					payload.lineIds?.join(',') === gpSelectedLineIds(payload) &&
+					payload.items?.every(item => item.type !== 'line' || gpLineChannelFields.every(key => item[key] === undefined))
+				check('onSelect / onSelectChange(通道回线)：单通道上下文只在顶层，items 不重复挂任何通道字段',
 					gpChannelPayloadOK(gpSelects.at(-1)) && gpChannelPayloadOK(gpChanges.at(-1)) && gpSelects.at(-1)?.items === gpChanges.at(-1)?.items,
-					JSON.stringify({ select: gpSelects.at(-1)?.channelId, change: gpChanges.at(-1)?.channelId, groups: gpSelects.at(-1)?.groups?.length, contexts: gpSelects.at(-1)?.channelContexts, items: gpSelects.at(-1)?.items?.map(item => ({ channelId: item.channelId, channelIndex: item.channelIndex, groupId: item.groupId, groupIndex: item.groupIndex, group: item.group, groups: item.groups })) }))
+					JSON.stringify({ select: gpSelects.at(-1)?.channelId, change: gpChanges.at(-1)?.channelId, groups: gpSelects.at(-1)?.groups?.length, lineIds: gpSelects.at(-1)?.lineIds, items: gpSelects.at(-1)?.items?.map(item => ({ id: item.item?.id, channelId: item.channelId, groupId: item.groupId })) }))
 				check('真实点击的派发顺序：onClick → onSelect → onSelectChange',
 					gpOrder.slice(-3).join('>') === 'click>select>selectChange',
 					gpOrder.join('>'))
@@ -513,8 +518,18 @@
 				gpOrder.length = 0
 				gpView.selectFeatures({ type: 'channel', channelId: 'gp-ch' })
 				check('selectFeatures(整条通道)：onSelect / onSelectChange 都带通道上下文，顺序是 onSelect → onSelectChange',
-					gpOrder.join('>') === 'select>selectChange' && gpChannelPayloadOK(gpSelects.at(-1)) && gpChannelPayloadOK(gpChanges.at(-1)) && gpSelects.at(-1)?.items?.length === 3,
+					gpOrder.join('>') === 'select>selectChange' && gpChannelPayloadOK(gpSelects.at(-1)) && gpChannelPayloadOK(gpChanges.at(-1)) && gpSelects.at(-1)?.items?.length === 3 && gpSelects.at(-1)?.lineIds?.join(',') === 'gp-l1,gp-l2,gp-l3',
 					JSON.stringify({ order: gpOrder, select: gpSelects.at(-1), change: gpChanges.at(-1) }))
+				const gpSelectionLines = gpView.getSelections().filter(entry => entry.type === 'line')
+				const gpOwner = gpView.getLineChannel(gpSelectionLines[0]?.index)
+				const gpSelectionData = gpView.getSelectionData()
+				check('getSelections / getSelectionData / getLineChannel：选中镜像不带通道字段，单条线路仍能反查通道与分组',
+					gpSelectionLines.length === 3 &&
+					gpSelectionLines.every(entry => gpLineChannelFields.every(key => entry[key] === undefined)) &&
+					gpSelectionData.items.every(entry => entry.type !== 'line' || gpLineChannelFields.every(key => entry[key] === undefined)) &&
+					gpSelectionData.channels.map(channel => String(channel.id)).join(',') === 'gp-ch' &&
+					String(gpOwner?.channelId) === 'gp-ch' && String(gpOwner?.channel?.id) === 'gp-ch' && gpOwner?.channelIndex === 0 && String(gpOwner?.group?.id) === 'gp-g1',
+					JSON.stringify({ lines: gpSelectionLines.length, owner: gpOwner && { channelId: gpOwner.channelId, channelIndex: gpOwner.channelIndex, groupId: gpOwner.groupId }, channels: gpSelectionData.channels.map(channel => channel.id) }))
 				gpOrder.length = 0
 				gpView.selectFeatures([
 					{ type: 'channel', channelId: 'gp-ch' },
@@ -529,7 +544,7 @@
 					gpSelects.at(-1).channelContexts.map(context => `${context.lineIndexes.length}/${context.lineIds.length}`).join(',') === '3/3,1/1' &&
 					gpSelects.at(-1).channelContexts.map(context => context.lineIds.join('+')).join(',') === 'gp-l1+gp-l2+gp-l3,gp-l4' &&
 					gpSelects.at(-1).items === gpChanges.at(-1)?.items &&
-					gpSelects.at(-1).items.every(item => item.type !== 'line' || (item.group === undefined && item.groups === undefined)),
+					gpSelects.at(-1).items.every(item => item.type !== 'line' || gpLineChannelFields.every(key => item[key] === undefined)),
 					JSON.stringify({ order: gpOrder, contexts: gpSelects.at(-1)?.channelContexts?.map(context => ({ channelId: context.channelId, lines: context.lineIds })), items: gpSelects.at(-1)?.items?.length }))
 				gpOrder.length = 0
 				const gpAt = gpView.selectAt(gpClientX, gpClientY)

package/docs/steps/step-05-pick.js

@@ -85,20 +85,16 @@ export const createPickView = (target, options = {}) => {
 	/** 点优先于线：两个都命中也算点中节点 */
 	const pick = (x, y) => pickPoint(x, y) ?? pickLine(x, y)
 
-	/** 统一的指针载荷：命中的元素 + 按钮 + 光标位置（空白处 type 为 null、hit 为 false） */
+	/** 统一的指针载荷：命中的元素 + 光标位置（空白处 type 为 null、hit 为 false；按键读 originalEvent） */
 	const pointerPayload = (hit, point, event) => ({
 		type: hit ? hit.type : null,
 		index: hit ? hit.index : -1,
 		item: hit ? hit.item : null,
 		hit: Boolean(hit),
 		...(hit ?? {}),
-		button: event.button,
-		buttons: event.buttons,
 		world: core.unproject(point[0], point[1]),
 		x: point[0],
 		y: point[1],
-		clientX: event.clientX,
-		clientY: event.clientY,
 		originalEvent: event
 	})
 	const canvasPointOf = event => {
@@ -180,7 +176,7 @@ export const createPickView = (target, options = {}) => {
 		const point = canvasPointOf(event)
 		const hit = pick(point[0], point[1])
 		// 左键 / 中键 / 右键都发一条：使用方在按下这一刻就能拿到光标下的元素
-		listeners.onPointerDown?.(pointerPayload(hit, point, event), event)
+		listeners.onPointerDown?.(pointerPayload(hit, point, event))
 		if (event.button !== 0) {
 			return
 		}
@@ -215,7 +211,7 @@ export const createPickView = (target, options = {}) => {
 		const point = canvasPointOf(event)
 		const hit = pick(point[0], point[1])
 		if (event.button === 0 || event.button === 2) {
-			listeners.onPointerUp?.(pointerPayload(hit, point, event), event)
+			listeners.onPointerUp?.(pointerPayload(hit, point, event))
 		}
 		const active = pressed
 		pressed = null
@@ -253,7 +249,7 @@ export const createPickView = (target, options = {}) => {
 	/** 右键：点、线、空白都发一条 onContextMenu，命中什么都在载荷里 */
 	const handleContextMenu = event => {
 		const point = canvasPointOf(event)
-		listeners.onContextMenu?.(pointerPayload(pick(point[0], point[1]), point, event), event)
+		listeners.onContextMenu?.(pointerPayload(pick(point[0], point[1]), point, event))
 	}
 
 	// 框选矩形：一个绝对定位的 DOM 层，样式由使用方决定（组件不内置界面）

package/docs/steps/step-07-channels.js

@@ -221,9 +221,9 @@ export const createChannelView = (target, options = {}) => {
 		onClick: payload => listeners.onClick?.(channelize(payload)),
 		onDblClick: payload => listeners.onDblClick?.(channelize(payload)),
 		onSelect: payload => listeners.onSelect?.(payload ? { ...payload, items: payload.items.map(channelize).filter(Boolean) } : null),
-		onPointerDown: (payload, event) => listeners.onPointerDown?.(channelize(payload), event),
-		onPointerUp: (payload, event) => listeners.onPointerUp?.(channelize(payload), event),
-		onContextMenu: (payload, event) => listeners.onContextMenu?.(channelize(payload), event)
+		onPointerDown: payload => listeners.onPointerDown?.(channelize(payload)),
+		onPointerUp: payload => listeners.onPointerUp?.(channelize(payload)),
+		onContextMenu: payload => listeners.onContextMenu?.(channelize(payload))
 	})
 
 	// ---------- 新增通道：草稿状态机 ----------
@@ -301,8 +301,6 @@ export const createChannelView = (target, options = {}) => {
 		x: point[0],
 		y: point[1],
 		world: core.unproject(point[0], point[1]),
-		clientX: event.clientX,
-		clientY: event.clientY,
 		originalEvent: event
 	})
 

package/docs/steps/step-08-labels.js

@@ -130,9 +130,9 @@ export const createLabelView = (target, options = {}) => {
 			renderTooltip(payload, payload ? payload.screen : null)
 			listeners.onHover?.(payload)
 		},
-		onPointerDown: (payload, event) => listeners.onPointerDown?.(payload, event),
-		onPointerUp: (payload, event) => listeners.onPointerUp?.(payload, event),
-		onContextMenu: (payload, event) => listeners.onContextMenu?.(payload, event)
+		onPointerDown: payload => listeners.onPointerDown?.(payload),
+		onPointerUp: payload => listeners.onPointerUp?.(payload),
+		onContextMenu: payload => listeners.onContextMenu?.(payload)
 	})
 	canvas.addEventListener('pointermove', handlePointerMove)
 	// 每帧同步一次标签：注册进第 1 步的渲染任务表，画的顺序在 WebGL 之后，谁都不挡谁

package/docs/steps/step-10-full.js

@@ -82,9 +82,9 @@ export const createFullView = (target, options = {}) => {
 		onClick: payload => forward.onClick?.(payload),
 		onDblClick: payload => forward.onDblClick?.(payload),
 		onSelect: payload => forward.onSelect?.(payload),
-		onPointerDown: (payload, event) => forward.onPointerDown?.(payload, event),
-		onPointerUp: (payload, event) => forward.onPointerUp?.(payload, event),
-		onContextMenu: (payload, event) => forward.onContextMenu?.(payload, event),
+		onPointerDown: payload => forward.onPointerDown?.(payload),
+		onPointerUp: payload => forward.onPointerUp?.(payload),
+		onContextMenu: payload => forward.onContextMenu?.(payload),
 		onChannelDraftClick: payload => forward.onChannelDraftClick?.(payload),
 		onChannelDraft: payload => {
 			if (payload?.phase === 'commit' && payload.lineId) {

package/docs/steps/step-12-events.js

@@ -9,21 +9,20 @@
  *     （select 选中 / clearSelection 点空白 / addWaypoint 加点 / contextMenu / dblClick）；
  *   - action.target：点在了什么上面（point / line / channel / empty）。通道回线的 type 也是 line，
  *     但要按通道处理，所以 target 单独给 channel；
- *   - action.data：按 target 直接取到的那份数据 —— 节点 / 线路是数据里那个对象、通道回线是通道定义、
- *     空白是 null。不用再去 payload.item / payload.channel 里翻；
- *   - action.button（left / middle / right，悬停是 none）、action.modifiers（ctrl / meta / shift / alt）、
- *     action.moved（这一次按下之后有没有真的拖动过）、action.double（是不是双击里的第二下）；
- *   - action.left / action.right：左键 / 右键的一眼判定（中键两边都是 false）；松开与点击载荷另带
- *     action.press（**按下时的意图**，与那一刻 onPointerDown 的 action.type 同一份）、action.duration
+ *   - 命中的数据直接读载荷：节点 / 线路读 payload.item、通道回线读 payload.channel、选中集读
+ *     payload.items、拐点读 payload.line，不再另打包一份 action.data；
+ *   - 按键 / 修饰键 / 指针位置读 payload.originalEvent（button / ctrlKey / metaKey / shiftKey / altKey /
+ *     clientX / clientY），action 只留 type / target / moved / double 这些判读；
+ *   - 松开与点击载荷另带 action.press（**按下时的意图**，与那一刻 onPointerDown 的 action.type 同一份）、action.duration
  *     （按了多久，毫秒）与 action.longPress（超过 500ms 且中间没拖动过 —— 触摸 / 触控笔按它出菜单）。
- *     中键按住就是临时平移：按下 / 松开的 action.type 都是 pan、action.button 是 middle，不经过 onClick。
+ *     中键按住就是临时平移：按下 / 松开的 action.type 都是 pan、originalEvent.button 是 1，不经过 onClick。
  *
  * 于是「按右键弹哪一份菜单」就是 switch (payload.action.target)，「拖完的是节点还是拐点」就是
  * switch (payload.action.type)，不用再各记一套 payload 形状。选中集变更也有同一套 action.type：
  * boxSelect / toggleSelect（Ctrl 点击取反）/ select / clearSelection —— 框选没框到东西与
  * 「点空白清空」在载荷上是同一个形状（都是 null），只有这一份补充读数能把它们分开。
  * 标签事件（labelClick / labelDrag / labelContextMenu / labelDblClick）同一套写法：
- * target 恒为 'label'、data 是 { label, parent }。
+ * target 恒为 'label'、标签与归属直接读载荷顶层的 label / parent。
  *
  * 两个只读查询：想主动问「这儿是什么」而不必先订阅一遍事件再把最近一次载荷记住，用
  *   - pickAt(clientX, clientY)：参数就是鼠标事件里的 clientX / clientY，返回与指针载荷同一份结果
@@ -59,7 +58,21 @@ const withChannels = (data) => {
 /** action.target -> 中文：日志里读起来不用记英文名 */
 const TARGET_NAMES = { point: '节点', line: '线路', channel: '通道回线', label: '标签', waypoint: '拐点', selection: '选中集', empty: '空白' }
 
-/** action.data 里那一份数据的名字：节点 / 线路看 name 与 id，选中集与标签给条数或内容 */
+/** 按 action.target 取载荷上那一份数据：节点 / 线路读 item、通道读 channel、选中集读 items */
+const dataOfAction = (payload, action) => {
+	if (Array.isArray(payload?.items)) {
+		return payload.items
+	}
+	if (payload?.label) {
+		return payload.label
+	}
+	if (action?.target === 'waypoint') {
+		return payload.line ?? null
+	}
+	return payload?.channel ?? payload?.item ?? null
+}
+
+/** 数据那一份的名字：节点 / 线路看 name 与 id，选中集与标签给条数或内容 */
 const nameOfData = (data) => {
 	if (Array.isArray(data)) {
 		return `${data.length} 个要素`
@@ -67,10 +80,6 @@ const nameOfData = (data) => {
 	if (!data || typeof data !== 'object') {
 		return ''
 	}
-	if (data.label) {
-		// 标签事件的 data 是 { label, parent }
-		return data.label.text ?? data.label.id ?? '标签'
-	}
 	return data.name ?? data.id ?? ''
 }
 
@@ -81,19 +90,27 @@ const describeAction = (payload, phase) => {
 		return `${phase}：—`
 	}
 	const parts = [action.type, `→ ${TARGET_NAMES[action.target] ?? action.target}`]
-	const name = nameOfData(action.data)
+	const name = nameOfData(dataOfAction(payload, action))
 	if (name !== '') {
 		parts.push(String(name))
 	}
-	parts.push(action.button === 'right' ? '右键' : action.button === 'middle' ? '中键' : '左键')
+	const button = payload.originalEvent?.button
+	if (button === 0 || button === 1 || button === 2) {
+		parts.push(button === 2 ? '右键' : button === 1 ? '中键' : '左键')
+	}
 	if (action.moved) {
 		parts.push('拖动过')
 	}
 	if (action.double) {
 		parts.push('双击的第二下')
 	}
-	const modifiers = action.modifiers ?? {}
-	const held = Object.keys(modifiers).filter(key => modifiers[key]).join('+')
+	const event = payload.originalEvent
+	const held = [
+		event?.ctrlKey ? 'ctrl' : null,
+		event?.metaKey ? 'meta' : null,
+		event?.shiftKey ? 'shift' : null,
+		event?.altKey ? 'alt' : null
+	].filter(Boolean).join('+')
 	if (held) {
 		parts.push(`按住 ${held}`)
 	}
@@ -121,13 +138,13 @@ export const createActionView = (target, options = {}) => {
 		waypointEditable: true,
 		features: { pan: true, zoom: true, hover: true, select: true, contextMenu: true, keyboard: true, channelDraft: true },
 		// 下面五条是同一条路：每个回调先报一句判读，再交给页面自己那一条（日志、草稿读数都还在）
-		onPointerDown: (payload, event) => {
+		onPointerDown: payload => {
 			report(describeAction(payload, '按下'))
-			options.onPointerDown?.(payload, event)
+			options.onPointerDown?.(payload)
 		},
-		onPointerUp: (payload, event) => {
+		onPointerUp: payload => {
 			report(describeAction(payload, '松开'))
-			options.onPointerUp?.(payload, event)
+			options.onPointerUp?.(payload)
 		},
 		onClick: payload => {
 			// 空白处的点击载荷是 null（选中已经清空）：这一下的判读在 onSelectChange 那条路上
@@ -138,13 +155,13 @@ export const createActionView = (target, options = {}) => {
 			report(describeAction(payload, '双击'))
 			options.onDblClick?.(payload)
 		},
-		onContextMenu: (payload, event) => {
+		onContextMenu: payload => {
 			report(describeAction(payload, '右键'))
-			options.onContextMenu?.(payload, event)
+			options.onContextMenu?.(payload)
 		},
 		// 选中集变更：action.type 把框选 / 取反 / 选中 / 清空分开（前两种不经过 onClick）
 		onSelectChange: event => {
-			report(`选中：${event.action.type} · ${event.count} 个（节点 ${event.points} / 线路 ${event.lines} / 通道 ${event.channels}）`)
+			report(`选中：${event.action.type} · ${event.count} 个（节点 ${event.points} / 线路 ${event.lines} / 通道 ${event.channels}）→ ${event.points ? '节点' : event.lines ? '线路' : event.channels ? '通道' : '空白'}`)
 			options.onSelectChange?.(event)
 		},
 		onCameraChange: camera => options.onCameraChange?.(camera)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gis-view-webgl2",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "WebGL2 矢量视图：点、线与 GeoJSON / 图片背景层，无内置界面，点击 / 双击 / 拖拽可配置",
   "type": "module",
   "scripts": {