写一个可调整大小的容器,我学到了什么
本文记录了实现可调整大小容器的完整思考过程,涵盖从全局事件监听到PointerEvent指针捕获的演进,解决多容器冲突、移动端兼容、边界失效、最小/最大尺寸限制、视觉反馈等关键问题,强调用户体验、边界容错与API设计哲学。
待至暮年归,挽手戏落日.
写一个可调整大小的容器,我学到了什么
前言
某天下午,产品经理走到我工位旁,带着几分期待的眼神说:"咱们那个弹窗,能不能让用户自己调整大小?"
我第一反应是——这不是很简单吗?不就是监听鼠标事件,计算位移,改宽改高吗?两个小时搞定的事。
于是我信心满满地答应了。
但真正开始写的时候,我发现事情并没有那么简单。这个看似简单的功能,背后藏着无数个让人抓狂的细节。
本文记录了我从最初的想法到最终实现的全过程,以及在这个过程中学到的每一个教训。
最初的思路:看起来很简单
1.1 我最初的方案
我的想法很直接:
- 在容器的边缘创建 8 个手柄(上下左右 + 四个角)
- 监听鼠标事件
- 计算鼠标移动的距离
- 根据移动方向调整容器的宽高
代码写出来大概是这样的:
javascript
function setupResize(container) {
// 创建手柄
const handles = createHandles(container)
// 监听鼠标按下
document.addEventListener('mousedown', (e) => {
if (e.target.classList.contains('resize-handle')) {
isResizing = true
activeHandle = e.target
startX = e.clientX
startY = e.clientY
startWidth = container.offsetWidth
startHeight = container.offsetHeight
}
})
// 监听鼠标移动
document.addEventListener('mousemove', (e) => {
if (!isResizing) return
const deltaX = e.clientX - startX
const deltaY = e.clientY - startY
// 根据手柄类型调整尺寸
if (activeHandle.dataset.edge === 'right') {
container.style.width = `${startWidth + deltaX}px`
}
// ... 其他方向
})
// 监听鼠标释放
document.addEventListener('mouseup', () => {
isResizing = false
})
}
看起来没问题对吧?写完测试了一下,能跑!我开心地提交了代码。
1.2 第一个问题:多个容器互相影响
两天后,测试同学来找我:"你看,我打开两个可调整大小的弹窗,拖拽其中一个的时候,另一个也会跟着动。"
我当时就懵了。仔细检查代码后,我发现了问题所在。
问题根源:我在全局 document 上监听事件。
当我在弹窗 A 的边缘按下鼠标,移动时 mousemove 事件被触发。但由于我在全局监听,这个事件并不知道我真正操作的是哪个弹窗。如果同时有两个弹窗,代码可能混淆了它们的状态。
1.3 第一次改进方案
我想到了一个办法:用 activeHandle 来标记当前正在操作的手柄,然后通过手柄找到对应的容器。
javascript
document.addEventListener('mousemove', (e) => {
if (!isResizing || !activeHandle) return
// 从手柄向上找容器
const container = activeHandle.closest('.resizable-container')
if (!container) return
// 现在可以安全地调整尺寸了
})
这个方案能工作,但总觉得不太优雅。全局监听就像在马路上喊话——声音太大,容易吵到别人。
PointerEvent:现代浏览器的礼物
2.1 移动端的噩梦
然后另一个问题来了。
"移动端用户说没法用。"测试同学又来找我了。
原来我只考虑了鼠标事件,没有处理触摸事件。在手机上,用户拖拽手柄时没有任何反应。
我赶紧加了触摸事件的支持:
javascript
document.addEventListener('mousedown', handleMouseDown)
document.addEventListener('touchstart', handleTouchStart)
document.addEventListener('mousemove', handleMouseMove)
document.addEventListener('touchmove', handleTouchMove)
document.addEventListener('mouseup', handleMouseUp)
document.addEventListener('touchend', handleTouchEnd)
但这样写有两个问题:
- 代码重复:鼠标和触摸的逻辑基本一样,但我要写两遍
- 维护困难:要改一个功能,得改两处地方
而且,触摸事件的坐标在 e.touches[0].clientX 里,鼠标事件的坐标在 e.clientX 里,每次都要判断事件类型来获取坐标,非常麻烦。
2.2 发现 PointerEvent
在一次偶然的机会,我了解到了 PointerEvent API。
PointerEvent 是 W3C 提出的统一指针事件标准,它用一套 API 同时处理鼠标、触摸、笔触等所有输入设备。而且,它的坐标统一在 e.clientX 和 e.clientY 里,不需要判断事件类型。
更重要的是,PointerEvent 提供了一个强大的特性:指针捕获。
2.3 指针捕获的魔力
setPointerCapture() 方法可以让后续的指针事件全部"锁定"在这个元素上,即使鼠标移出了元素边界,事件也会继续触发。
typescript
const handlePointerDown = (edge: ResizeEdge, event: PointerEvent) => {
const handle = event.target as HTMLElement
// 设置指针捕获!
handle.setPointerCapture(event.pointerId)
// 后续的事件都会被捕获到这个手柄上
handle.addEventListener('pointermove', handlePointerMove)
handle.addEventListener('pointerup', handlePointerUp)
}
这意味着什么?
- 不需要全局监听:事件只在手柄上触发,不会污染全局环境
- 自动处理边界:即使鼠标移出浏览器窗口,事件也能被捕获
- 完美解决多容器问题:每个容器的事件是隔离的
我重写了整个事件处理逻辑,代码一下子变得优雅了很多。
typescript
const setupPointerCapture = (handle: HTMLElement, event: PointerEvent) => {
handle.setPointerCapture(event.pointerId)
handle.addEventListener('pointermove', handlePointerMove)
handle.addEventListener('pointerup', handlePointerUp)
}
const releasePointerCapture = (handle: HTMLElement, event: PointerEvent) => {
handle.releasePointerCapture(event.pointerId)
handle.removeEventListener('pointermove', handlePointerMove)
handle.removeEventListener('pointerup', handlePointerUp)
}
PointerEvent 的使用,让我体会到了现代 API 带来的优雅。很多时候,我们遇到的难题,已经有标准 API 提供了解决方案,只是我们没有去了解。
那个让人头疼的边界问题
3.1 问题重现
我以为功能终于完成了,正准备提交代码,测试的时候又发现了问题。
用户把弹窗拖到最大,边缘紧贴浏览器窗口。然后——手柄看不见了,鼠标也 hover 不到。
弹窗变得无法缩小,就像被困在自己的边界里。
用户报告的问题是这样的:
"我把弹窗拉大,结果边缘贴在浏览器边上,那个小白点被遮挡了。我怎么缩小啊?"
3.2 分析问题
让我画个图来说明一下:
┌─────────────────────────────────────────┐
│ 浏览器窗口 │
│ │
│ ┌───────────────────────┐ │
│ │ │ │
│ │ 弹窗容器 │ │
│ │ │ │
│ └───────────────────────┘ │
│ ↑ │
│ 手柄在这里 │
└─────────────────────────────────────────┘
当弹窗的右边缘与浏览器右边缘重合时,右边缘的手柄就在浏览器边缘上。问题是:
- 手柄只有 8 像素宽,一半在窗口内,一半在窗口外
- 鼠标移到窗口外,浏览器不会响应
- 用户无法 hover 到手柄,也就无法拖拽它缩小弹窗
这是一个死锁状态。
3.3 解决方案:safeMargin
我想到了一个解决方案:给浏览器边缘留一点安全距离。
typescript
const DEFAULT_SAFE_MARGIN = 10
const getMaxDimensions = (container: HTMLElement, edge: ResizeEdge) => {
const rect = container.getBoundingClientRect()
const viewport = {
width: window.innerWidth,
height: window.innerHeight,
}
let maxW = maxWidth
let maxH = maxHeight
// 计算最大宽度时减去安全边距
if (edgeIncludesDirection(edge, EdgeDirection.Right)) {
const maxRightWidth = viewport.width - rect.left - safeMargin
maxW = maxW !== undefined ? Math.min(maxW, maxRightWidth) : maxRightWidth
}
return { maxWidth: maxW, maxHeight: maxH }
}
这样,弹窗永远不会贴到浏览器边缘,手柄永远有呼吸的空间。
┌─────────────────────────────────────────┐
│ 浏览器窗口 │
│ │
│ ┌─────────────────────────┐ │
│ │ │ │
│ │ 弹窗容器 │ │
│ │ │ │
│ └─────────────────────────┘ │
│ ↑ ←─ 10px 空间 │
│ 手柄在这里 │
└─────────────────────────────────────────┘
3.4 更深入的思考
这个 safeMargin 的设计让我思考了很多。
设计不仅要考虑用户能做什么,还要考虑他们想反悔时该怎么办。
如果用户放大了一个窗口,他们很可能还想把它缩小回去。如果缩小的方法被堵死了,那这个交互就是有问题的。
safeMargin 本质上是一个逃生通道。无论用户怎么操作,都留一条退路。
这让我想到了另一个例子:删除确认对话框。为什么很多应用在你删除文件时,会问你"确定删除吗"?不是因为怕你手滑,而是给你一个反悔的机会。
用户体验不是让用户永远做正确的选择,而是让用户即使做了"错误"的选择,也有回头的余地。
八个边缘,还是两个?
4.1 不同的场景,不同的需求
随着功能的推进,我开始收到不同的反馈。
场景 A:侧边栏
"我想让侧边栏可以调整宽度,但不需要调整高度。"
场景 B:聊天窗口
"聊天窗口只需要调整高度,宽度是固定的。"
场景 C:自由弹窗
"这个弹窗需要随意调整大小,上下左右都要。"
显然,一个统一的方案无法满足所有需求。
4.2 设计 dimension 参数
我设计了 dimension 参数,让调用者自己决定需要哪些边缘:
typescript
export type ResizeDimension = 'width' | 'height' | 'both'
export interface UseResizeableOptions {
dimension?: ResizeDimension
// ... 其他选项
}
然后根据 dimension 动态生成可用的边缘:
typescript
const getEffectiveEdges = (): ResizeEdge[] => {
const dimension = options.dimension ?? 'both'
const edgeMap: Record<ResizeDimension, ResizeEdge[]> = {
width: ['left', 'right'],
height: ['top', 'bottom'],
both: ['top', 'right', 'bottom', 'left', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight'],
}
return edgeMap[dimension] || edgeMap.both
}
4.3 给用户选择权
这个设计让我学到了——给用户选择权,比什么都给更重要。
如果我把所有 8 个边缘都给用户,他们可能只需要左右两个,多出来的 6 个反而会让他们困惑:"这些手柄是干嘛的?能拖吗?"
但如果我只给他们需要的边缘,他们就会觉得"这个功能正好满足我的需求"。
这种最小可用性(Minimum Viable)的设计理念,在很多地方都适用。给用户最合适的功能,而不是最多的功能。
原始尺寸的记忆
5.1 一个奇怪的需求
有一天,产品经理又来了:"用户说,弹窗缩小后,能一键恢复到原来的大小吗?"
这个需求听起来很简单:保存原始尺寸,然后在需要的时候恢复。
但问题来了——什么是"原来的大小"?
5.2 原始尺寸的定义
我首先想到的是,在每次初始化时记录当前尺寸:
typescript
const doInit = () => {
const container = unref(el)
if (!container) return
const rect = container.getBoundingClientRect()
originalWidth = rect.width
originalHeight = rect.height
createHandles()
}
但这样有问题。
假设用户操作流程是这样的:
- 弹窗初始尺寸是 500x500,记录
originalWidth = 500 - 用户调整到 800x800
- 用户关闭弹窗
- 用户再次打开弹窗,此时尺寸是 800x800(可能被保留了)
- 用户缩小到 300x300
- 用户点击"恢复原始大小",应该恢复到多少?
如果每次初始化都记录,那么 originalWidth 会被更新为 800,恢复时就会恢复到 800x800,而不是最初的 500x500。
5.3 最终方案:只记录第一次
我的方案是:只记录第一次初始化时的尺寸。
typescript
let originalWidth: number | null = null
let originalHeight: number | null = null
const recordOriginalSize = (rect: DOMRect) => {
if (originalWidth === null) {
originalWidth = rect.width
}
if (originalHeight === null) {
originalHeight = rect.height
}
}
const resetOriginalSize = () => {
originalWidth = null
originalHeight = null
}
const doInit = () => {
const container = unref(el)
if (!container) return
resetOriginalSize()
const rect = container.getBoundingClientRect()
recordOriginalSize(rect)
createHandles()
}
这样,无论用户之后怎么操作,"原始尺寸"永远是第一次打开弹窗时的尺寸。
5.4 allowShrink 参数
原始尺寸的另一个用途是控制是否允许缩小。
有些场景下,你不希望用户把弹窗缩得比初始尺寸还小。所以我加了一个 allowShrink 参数:
typescript
const getEffectiveMinSize = (originalSize: number, minSize: number): number => {
return allowShrink ? minSize : Math.max(minSize, originalSize)
}
如果 allowShrink = false,最小尺寸就是 min(minWidth, originalWidth) 的较大值。
这就像人的记忆——第一次的印象往往最深刻。无论之后发生了什么,最初的那个样子,总是有一个特殊的位置。
手柄的视觉反馈
6.1 看不见的手柄
最初,我把手柄做得很低调——2 像素宽的白色线条。
但测试时我发现,用户根本不知道这个容器是可以调整大小的。他们看到弹窗,就以为这就是固定尺寸。
没有反馈,用户就没有认知。
6.2 悬停变色
我给手柄加了悬停效果:
typescript
const attachHandleEvents = (handle: HTMLElement, edge: ResizeEdge) => {
handle.addEventListener('mouseenter', () => {
if (!isResizing.value) {
handle.style.backgroundColor = handleHoverColor
}
})
handle.addEventListener('mouseleave', () => {
if (!isResizing.value) {
handle.style.backgroundColor = handleColor
}
})
}
当鼠标移上去时,手柄从白色变成蓝色。
只有 0.2 秒的过渡,但这个微小的反馈告诉用户:"我在这里,你可以操作我了。"
6.3 拖拽时的状态保持
还有一个细节:当用户正在拖拽时,我不希望手柄在鼠标移出时变色回去。
typescript
handle.addEventListener('mouseenter', () => {
if (!isResizing.value) { // ← 注意这个判断
handle.style.backgroundColor = handleHoverColor
}
})
因为在拖拽时,手柄的颜色会一直是激活色,这样用户知道当前正在操作哪个手柄。
6.4 光标的重要性
光标(cursor)也是一种重要的反馈。
typescript
const getHandleStyleConfig = (edge: ResizeEdge, handleSize: number): HandleStyleConfig => {
const edgeConfig: Record<string, HandleStyleConfig> = {
top: { cursor: 'row-resize' }, // 上下箭头
right: { cursor: 'col-resize' }, // 左右箭头
bottom: { cursor: 'row-resize' }, // 上下箭头
left: { cursor: 'col-resize' }, // 左右箭头
// 角落的手柄用斜向箭头
topLeft: { cursor: 'nwse-resize' },
topRight: { cursor: 'nesw-resize' },
// ...
}
return edgeConfig[edge]
}
当鼠标移到上边缘时,光标变成上下箭头;移到右边缘时,变成左右箭头;移到角落时,变成斜向箭头。
这些细节都在告诉用户:"这里可以拖拽,而且是这样拖拽的。"
UI 设计里,这种反馈比我们想象的更重要。看不见的功能,对用户来说就是不存在。
最小尺寸和最大尺寸
7.1 为什么需要最小尺寸?
如果你不设置最小尺寸,用户可能会把弹窗缩得非常小,小到内容无法显示。
这有两个问题:
- 体验问题:弹窗太小,内容被挤压,用户看不清
- bug 问题:某些布局在小尺寸下会崩溃
所以设置一个合理的最小尺寸是必要的。
7.2 默认值的选择
我选择 100px 作为默认的最小宽度和高度。
为什么是 100?
- 小于 100px,基本上什么都放不下
- 100px 是一个"感觉上可以接受"的最小值
- 用户如果需要更小,可以自己配置
typescript
const DEFAULT_MIN_SIZE = 100
const {
minWidth = DEFAULT_MIN_SIZE,
minHeight = DEFAULT_MIN_SIZE,
} = options
7.3 最大尺寸的复杂性
最大尺寸的问题比较复杂,因为它涉及两个维度:
- 用户配置的最大尺寸:用户可能有自己的限制
- 视口边界:弹窗不能超过浏览器窗口
我的做法是,取两者的较小值:
typescript
const getMaxDimensions = (container: HTMLElement, edge: ResizeEdge) => {
if (!boundToViewport) {
return { maxWidth, maxHeight }
}
const rect = container.getBoundingClientRect()
const viewport = getViewportBounds()
let maxW = maxWidth
let maxH = maxHeight
// 计算基于视口边界的最大尺寸
if (edgeIncludesDirection(edge, EdgeDirection.Right)) {
const maxRightWidth = viewport.width - rect.left - safeMargin
maxW = maxW !== undefined ? Math.min(maxW, maxRightWidth) : maxRightWidth
}
return { maxWidth: maxW, maxHeight: maxH }
}
如果用户设置了 maxWidth = 600,但视口只允许放大到 500,那么实际最大尺寸就是 500。
7.4 clamp 函数的通用性
为了处理各种边界情况,我写了一个 clamp 函数:
typescript
const clamp = (value: number, min: number, max?: number): number => {
const clampedValue = Math.max(min, value)
return max !== undefined ? Math.min(max, clampedValue) : clampedValue
}
这个函数的作用是:把一个值限制在指定的范围内。
typescript
clamp(5, 10, 100) // → 10(小于最小值,返回最小值)
clamp(50, 10, 100) // → 50(在范围内,返回原值)
clamp(150, 10, 100) // → 100(大于最大值,返回最大值)
这样的工具函数虽然简单,但复用性很高,在计算尺寸时非常有用。
事件回调的设计
8.1 三种回调
我在代码中设计了三种回调:
typescript
export interface UseResizeableOptions {
onResizeStart?: (data: ResizeEventData) => void
onResize?: (data: ResizeEventData) => void
onResizeEnd?: (data: ResizeEventData) => void
}
它们分别在调整开始、调整过程中、调整结束时被调用。
8.2 为什么需要这么多回调?
你可能问:一个 onResize 不就够了吗?
但不同的场景有不同的需求:
场景 A:保存用户偏好
用户每次调整完弹窗大小,就保存到本地存储,下次打开时恢复。
typescript
useResizeable(el, {
onResizeEnd: (data) => {
localStorage.setItem('dialogSize', `${data.width},${data.height}`)
}
})
场景 B:实时调整内部内容
用户调整弹窗大小的同时,内部内容也要响应调整。
typescript
useResizeable(el, {
onResize: (data) => {
chart.resize()
}
})
场景 C:记录用户行为
分析用户如何使用这个功能,用于产品优化。
typescript
useResizeable(el, {
onResizeStart: (data) => {
trackEvent('resize_start', { edge: data.edge })
},
onResizeEnd: (data) => {
trackEvent('resize_end', {
edge: data.edge,
duration: Date.now() - startTime,
sizeChange: data.width - data.startWidth
})
}
})
8.3 事件数据的完整性
回调的事件数据包含了很多信息:
typescript
export interface ResizeEventData {
element: HTMLElement // 容器元素
edge: ResizeEdge // 触发调整的边缘
width: number // 新的宽度
height: number // 新的高度
startWidth: number // 初始宽度
startHeight: number // 初始高度
startX: number // 鼠标初始X坐标
startY: number // 鼠标初始Y坐标
currentX: number // 鼠标当前X坐标
currentY: number // 鼠标当前Y坐标
originalEvent: PointerEvent // 原始事件
}
为什么这么多?
因为不同的用户需要不同的信息。有的需要知道调整了多少,有的需要知道从哪个边缘调整的,有的需要原始事件来做更复杂的处理。
提供充分的信息,让用户自己决定用哪些,是一个好的设计。
性能优化
9.1 事件节流
在调整大小时,pointermove 事件会频繁触发(可能一秒几十次)。如果在每次移动时都做大量计算,可能会导致性能问题。
在这个场景下,我没有做显式的节流,因为:
- 计算很简单:只是计算宽度和高度,没有复杂的 DOM 操作
- PointerEvent 已经优化过:浏览器对指针事件有优化
- 用户体验需要:节流会让调整过程显得卡顿
但如果你的场景很复杂,比如调整时需要重新渲染整个图表,那可能需要考虑节流:
typescript
import { useThrottleFn } from '@vueuse/core'
const handlePointerMove = useThrottleFn((event: PointerEvent) => {
if (!isResizing.value || !resizeData) return
event.preventDefault()
performPointerResize(event)
}, 16) // 约 60fps
9.2 样式计算优化
在创建手柄时,我把样式配置提取成函数:
typescript
const getHandleStyleConfig = (edge: ResizeEdge, handleSize: number): HandleStyleConfig => {
// ... 返回样式配置
}
这样可以避免重复计算样式,提高性能。
9.3 DOM 操作优化
每次调整大小时,我只修改 width 和 height 两个样式属性:
typescript
const applySize = (container: HTMLElement, width: number, height: number) => {
container.style.width = `${width}px`
container.style.height = `${height}px`
}
避免触发不必要的重排和重绘。
边缘情况的思考
10.1 容器不存在时怎么办?
用户传入的容器可能不存在,或者还没有挂载到 DOM 上。
我的处理是:
typescript
const doInit = () => {
const container = unref(el)
if (!container) {
console.warn('[useResizeable] 元素不存在,无法初始化')
return
}
if (isInitialized.value) return
resetOriginalSize()
createHandles()
isInitialized.value = true
}
打印一个警告,然后优雅地退出,不会让整个应用崩溃。
10.2 元素被销毁后怎么办?
当 Vue 组件被销毁时,要清理事件监听和手柄:
typescript
onUnmounted(() => {
destroy()
})
const destroy = () => {
stopResize()
clearHandles()
}
避免内存泄漏。
10.3 手柄被用户删除了怎么办?
理论上,手柄可能会被其他代码删除。如果这种情况发生了,后续的事件监听可能会出错。
在这个场景下,我没有做特殊处理。如果用户手动删除了手柄,那功能就会失效。这是用户自己选择的行为,hook 不需要负责。
Vue 3 的响应式设计
11.1 返回 Ref 的状态
我使用了 Vue 3 的响应式系统:
typescript
const isResizing = ref(false)
const activeEdge = ref<ResizeEdge | null>(null)
const element = ref<HTMLElement | null>(null)
return {
isResizing,
activeEdge,
element,
init,
stopResize,
destroy,
}
这样,用户可以在模板中使用这些状态:
vue
<template>
<div ref="dialogRef" class="dialog">
<div v-if="isResizing" class="hint">正在调整大小...</div>
</div>
</template>
<script setup>
import { useResizeable } from './useResizeable'
const dialogRef = ref<HTMLElement | null>(null)
const { isResizing } = useResizeable(dialogRef)
</script>
11.2 支持 Ref 和 HTMLElement 两种输入
为了让使用更灵活,我支持传入 Ref 或者直接传入 HTMLElement:
typescript
export function useResizeable(
el: HTMLElement | Ref<HTMLElement | null>,
options: UseResizeableOptions = {},
): ResizeableState {
// ...
}
使用方式:
typescript
// 方式 1:传入 Ref
const elRef = ref<HTMLElement | null>(null)
useResizeable(elRef)
// 方式 2:直接传入元素
useResizeable(document.getElementById('my-dialog'))
11.3 简化版 hook
考虑到很多场景下需要创建自己的 Ref,我提供了一个简化版:
typescript
export function useResizeableContainer(options: UseResizeableOptions = {}) {
const elementRef = ref<HTMLElement | null>(null)
const { isResizing, activeEdge, element, init, stopResize, destroy } = useResizeable(
elementRef,
options,
)
return {
elementRef,
isResizing,
activeEdge,
element,
init,
stopResize,
destroy,
}
}
使用起来更简洁:
vue
<script setup>
import { useResizeableContainer } from './useResizeable'
const { elementRef, isResizing } = useResizeableContainer()
</script>
<template>
<div ref="elementRef" class="resizable">
<!-- ... -->
</div>
</template>
未来的改进方向
虽然这个功能已经基本完成,但还有一些可以改进的地方:
12.1 支持比例锁定
有时候用户希望在调整大小时保持宽高比:
typescript
export interface UseResizeableOptions {
lockAspectRatio?: boolean // 锁定宽高比
}
12.2 支持预设尺寸
提供一些常用的预设尺寸:
typescript
export interface UseResizeableOptions {
presets?: {
small?: { width: number; height: number }
medium?: { width: number; height: number }
large?: { width: number; height: number }
}
}
12.3 支持吸附效果
让容器在调整时吸附到某些尺寸:
typescript
export interface UseResizeableOptions {
snapTo?: {
width?: number[]
height?: number[]
threshold?: number
}
}
12.4 支持动画
在尺寸变化时添加平滑过渡:
typescript
export interface UseResizeableOptions {
animate?: boolean
animationDuration?: number
}
这些功能都可以在后续迭代中逐步添加。
写在最后
这个小小的 useResizeable hook,我写了两三天。
不是因为代码复杂,而是因为我在思考:用户真正需要什么?
他们需要:
- 精确的控制,但也需要反悔的余地
- 统一的体验,无论是鼠标还是触摸
- 清晰的反馈,知道自己可以做什么
- 适度的选择,不要什么都被塞进手里
代码是冰冷的,但写代码的人可以是有温度的。
当你用到一个好用的交互时,背后一定有人在想:"我该怎么让用户觉得舒服?"
这大概就是前端开发的意义吧。
代码示例
typescript
import { ref, onUnmounted, unref, watch, type Ref } from 'vue'
const { isResizing, activeEdge, element, init, stopResize, destroy } = useResizeable(
dialogRef,
{
dimension: 'both', // 可以调整宽度和高度
minWidth: 300, // 最小宽度 300px
minHeight: 200, // 最小高度 200px
maxWidth: 800, // 最大宽度 800px
boundToViewport: true, // 限制在浏览器窗口内
safeMargin: 10, // 留 10px 安全边距
allowShrink: true, // 允许缩小
handleColor: '#fff', // 手柄颜色
handleHoverColor: '#1890ff',// 悬停颜色
showHandles: true, // 显示手柄
onResizeEnd: (data) => {
console.log('调整完成', data)
}
}
)
完整代码
typescript
import { ref, onUnmounted, unref, watch, type Ref, isRef } from 'vue';
/**
* 可调整大小的边缘方向
*/
export type ResizeEdge =
| 'top'
| 'right'
| 'bottom'
| 'left'
| 'topLeft'
| 'topRight'
| 'bottomLeft'
| 'bottomRight';
/**
* 调整大小维度
*/
export type ResizeDimension = 'width' | 'height' | 'both';
/**
* 边缘方向枚举(用于边缘检查)
*/
enum EdgeDirection {
Top = 'top',
Right = 'right',
Bottom = 'bottom',
Left = 'left',
}
/**
* 手柄样式配置
*/
interface HandleStyleConfig {
top?: string;
right?: string;
bottom?: string;
left?: string;
width?: string;
height?: string;
cursor?: string;
borderRadius?: string;
}
/**
* 调整大小的选项配置
*/
export interface UseResizeableOptions {
/**
* 可调整大小的维度
* - 'width': 只能调整宽度,启用左右边缘拖拽
* - 'height': 只能调整高度,启用上下边缘拖拽
* - 'both': 可以同时调整宽度和高度,启用上下左右及四个角拖拽
* @default 'both'
*/
dimension?: ResizeDimension;
/**
* 是否限制在浏览器视口边界内
* - true: 容器不能超过浏览器可视区域
* - false: 容器可以超出浏览器边界
* @default true
*/
boundToViewport?: boolean;
/**
* 浏览器边缘的安全距离(像素)
* @description
* 容器放大时会与浏览器边缘保持此距离,确保调整手柄始终可见和可操作
* 避免容器放大到窗口边缘后,鼠标无法 hover 手柄导致无法缩小
* @default 10
*/
safeMargin?: number;
/**
* 是否允许缩小到小于容器原始尺寸
* - true: 允许缩小,最小尺寸由 minWidth/minHeight 控制
* - false: 不允许缩小,最小尺寸为原始宽度和 minHeight 的较大值
* @default true
*/
allowShrink?: boolean;
/**
* 最小宽度
* @default 100
*/
minWidth?: number;
/**
* 最小高度
* @default 100
*/
minHeight?: number;
/**
* 最大宽度
*/
maxWidth?: number;
/**
* 最大高度
*/
maxHeight?: number;
/**
* 调整边缘线条的粗细
* @default 2
*/
handleSize?: number;
/**
* 调整边缘线条的颜色
* @default '#d9d9d9'
*/
handleColor?: string;
/**
* 调整边缘线条的悬停颜色
* @default '#1890ff'
*/
handleHoverColor?: string;
/**
* 是否显示调整手柄
* @default true
*/
showHandles?: boolean;
/**
* 是否立即初始化(创建手柄)
* - true: 在 hook 创建时自动初始化
* - false: 返回 init 函数,由用户手动调用初始化
* @default true
*/
immediate?: boolean;
/**
* 调整开始时的回调
*/
onResizeStart?: (data: ResizeEventData) => void;
/**
* 调整过程中的回调
*/
onResize?: (data: ResizeEventData) => void;
/**
* 调整结束时的回调
*/
onResizeEnd?: (data: ResizeEventData) => void;
}
/**
* 调整大小的事件数据
*/
export interface ResizeEventData {
/**
* 容器元素
*/
element: HTMLElement;
/**
* 触发调整的边缘方向
*/
edge: ResizeEdge;
/**
* 新的宽度
*/
width: number;
/**
* 新的高度
*/
height: number;
/**
* 初始宽度
*/
startWidth: number;
/**
* 初始高度
*/
startHeight: number;
/**
* 鼠标/触摸初始X坐标
*/
startX: number;
/**
* 鼠标/触摸初始Y坐标
*/
startY: number;
/**
* 鼠标/触摸当前X坐标
*/
currentX: number;
/**
* 鼠标/触摸当前Y坐标
*/
currentY: number;
/**
* 原始事件
*/
originalEvent: PointerEvent;
}
/**
* 调整大小的状态
*/
export interface ResizeableState {
/**
* 是否正在调整大小
*/
isResizing: Ref<boolean>;
/**
* 当前调整的边缘方向
*/
activeEdge: Ref<ResizeEdge | null>;
/**
* 当前容器元素
*/
element: Ref<HTMLElement | null>;
/**
* 初始化(创建手柄)
* 当 immediate=false 时,需要手动调用此方法来初始化
*/
init: () => void;
/**
* 停止调整大小
*/
stopResize: () => void;
/**
* 销毁
*/
destroy: () => void;
}
/**
* 可调整容器大小的 Hook
*
* @description
* 优化说明:使用 PointerEvent + setPointerCapture API,避免了全局 document 事件监听:
* 1. 指针捕获在手柄元素上,不需要全局监听
* 2. 自动处理鼠标和触摸事件的统一
* 3. 性能更好,内存占用更少
*
* @param el - 容器元素或Ref
* @param options - 配置选项
* @returns 调整大小的状态和方法
*/
export function useResizeable(
el: HTMLElement | Ref<HTMLElement | null>,
options: UseResizeableOptions = {},
): ResizeableState {
// ==================== 常量配置 ====================
const DEFAULT_MIN_SIZE = 100;
const DEFAULT_HANDLE_SIZE = 2;
const DEFAULT_SAFE_MARGIN = 10;
const CORNER_HANDLE_SIZE = 8;
const HANDLE_Z_INDEX = 1000;
// ==================== 工具函数 ====================
/**
* 根据 dimension 获取有效的边缘
*/
const getEffectiveEdges = (): ResizeEdge[] => {
const dimension = options.dimension ?? 'both';
const edgeMap: Record<ResizeDimension, ResizeEdge[]> = {
width: ['left', 'right'],
height: ['top', 'bottom'],
both: ['top', 'right', 'bottom', 'left', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight'],
};
return edgeMap[dimension] || edgeMap.both;
};
/**
* 检查边缘是否包含指定方向
* @param edge - 边缘类型
* @param direction - 方向
* @returns 是否包含该方向
*/
const edgeIncludesDirection = (edge: ResizeEdge, direction: EdgeDirection): boolean => {
return edge.toLowerCase().includes(direction);
};
/**
* 获取手柄的样式配置
* @param edge - 边缘类型
* @param handleSize - 线条粗细
* @returns 样式配置对象
*/
const getHandleStyleConfig = (edge: ResizeEdge, handleSize: number): HandleStyleConfig => {
const isCorner = edge.includes('Left') || edge.includes('Right');
if (isCorner) {
// 角落手柄样式(圆点)
const cornerConfig: Record<string, HandleStyleConfig> = {
topLeft: {
top: '0',
left: '0',
width: `${CORNER_HANDLE_SIZE}px`,
height: `${CORNER_HANDLE_SIZE}px`,
cursor: 'nwse-resize',
borderRadius: '50%',
},
topRight: {
top: '0',
right: '0',
width: `${CORNER_HANDLE_SIZE}px`,
height: `${CORNER_HANDLE_SIZE}px`,
cursor: 'nesw-resize',
borderRadius: '50%',
},
bottomLeft: {
bottom: '0',
left: '0',
width: `${CORNER_HANDLE_SIZE}px`,
height: `${CORNER_HANDLE_SIZE}px`,
cursor: 'nesw-resize',
borderRadius: '50%',
},
bottomRight: {
bottom: '0',
right: '0',
width: `${CORNER_HANDLE_SIZE}px`,
height: `${CORNER_HANDLE_SIZE}px`,
cursor: 'nwse-resize',
borderRadius: '50%',
},
};
return cornerConfig[edge];
}
// 单一边缘手柄样式(线条)row-resize
const edgeConfig: Record<string, HandleStyleConfig> = {
top: {
top: '0',
left: '0',
right: '0',
height: `${handleSize}px`,
cursor: 'row-resize',
},
right: {
top: '0',
right: '0',
bottom: '0',
width: `${handleSize}px`,
cursor: 'col-resize',
},
bottom: {
bottom: '0',
left: '0',
right: '0',
height: `${handleSize}px`,
cursor: 'row-resize',
},
left: {
top: '0',
left: '0',
bottom: '0',
width: `${handleSize}px`,
cursor: 'col-resize',
},
};
return edgeConfig[edge];
};
/**
* 限制数值在指定范围内
* @param value - 待限制的值
* @param min - 最小值
* @param max - 最大值
* @returns 限制后的值
*/
const clamp = (value: number, min: number, max?: number): number => {
const clampedValue = Math.max(min, value);
return max !== undefined ? Math.min(max, clampedValue) : clampedValue;
};
// ==================== 配置项 ====================
const edges = getEffectiveEdges();
const {
minWidth = DEFAULT_MIN_SIZE,
minHeight = DEFAULT_MIN_SIZE,
maxWidth,
maxHeight,
handleSize = DEFAULT_HANDLE_SIZE,
handleColor = '#fff',
handleHoverColor = '#1890ff',
showHandles = true,
immediate = true,
boundToViewport = true,
safeMargin = DEFAULT_SAFE_MARGIN,
allowShrink = true,
onResizeStart,
onResize,
onResizeEnd,
} = options;
const isResizing = ref(false);
const activeEdge = ref<ResizeEdge | null>(null);
const element = ref<HTMLElement | null>(null);
const isInitialized = ref(false);
// 记录容器的原始尺寸(首次初始化时记录)
let originalWidth: number | null = null;
let originalHeight: number | null = null;
// 内部状态
let resizeData: {
startWidth: number;
startHeight: number;
startX: number;
startY: number;
currentEdge: ResizeEdge;
} | null = null;
let handles: HTMLElement[] = [];
// ==================== 手柄管理 ====================
/**
* 创建调整手柄
*/
const createHandles = () => {
const container = unref(el);
if (!container) return;
clearHandles();
if (!showHandles) return;
edges.forEach((edge) => {
const handle = createHandle(edge);
container.appendChild(handle);
handles.push(handle);
});
};
/**
* 创建单个手柄元素
* @param edge - 边缘类型
* @returns 手柄元素
*/
const createHandle = (edge: ResizeEdge): HTMLElement => {
const handle = document.createElement('div');
handle.className = `resize-handle resize-handle-${edge}`;
handle.dataset.edge = edge;
// 设置基础样式
Object.assign(handle.style, {
position: 'absolute',
zIndex: `${HANDLE_Z_INDEX}`,
backgroundColor: handleColor,
transition: 'background-color 0.2s ease',
touchAction: 'none', // 防止触摸滚动
...getHandleStyleConfig(edge, handleSize),
} as CSSStyleDeclaration);
// 添加事件监听
attachHandleEvents(handle, edge);
return handle;
};
/**
* 为手柄添加事件监听
* @param handle - 手柄元素
* @param edge - 边缘类型
*/
const attachHandleEvents = (handle: HTMLElement, edge: ResizeEdge) => {
// 悬停效果
handle.addEventListener('mouseenter', () => {
if (!isResizing.value) {
handle.style.backgroundColor = handleHoverColor;
}
});
handle.addEventListener('mouseleave', () => {
if (!isResizing.value) {
handle.style.backgroundColor = handleColor;
}
});
// 拖拽事件
handle.addEventListener('pointerdown', (e: PointerEvent) => handlePointerDown(edge, e));
};
/**
* 清除所有手柄
*/
const clearHandles = () => {
handles.forEach((handle) => {
if (handle.parentNode) {
handle.parentNode.removeChild(handle);
}
});
handles = [];
};
// ==================== 事件处理 ====================
/**
* 统一的指针事件处理
* @param edge - 边缘类型
* @param event - 指针事件
*/
const handlePointerDown = (edge: ResizeEdge, event: PointerEvent) => {
const container = unref(el);
const handle = event.target as HTMLElement;
if (!container || !handle) return;
event.preventDefault();
event.stopPropagation();
const rect = container.getBoundingClientRect();
recordOriginalSize(rect);
initializeResizeData(rect, edge, event);
updateResizeState(container, edge, handle);
setupPointerCapture(handle, event);
triggerResizeStartCallback(container, edge, rect, event);
};
/**
* 记录原始尺寸
* @param rect - 容器边界矩形
*/
const recordOriginalSize = (rect: DOMRect) => {
if (originalWidth === null) {
originalWidth = rect.width;
}
if (originalHeight === null) {
originalHeight = rect.height;
}
};
/**
* 初始化调整数据
* @param rect - 容器边界矩形
* @param edge - 边缘类型
* @param event - 指针事件
*/
const initializeResizeData = (rect: DOMRect, edge: ResizeEdge, event: PointerEvent) => {
resizeData = {
startWidth: rect.width,
startHeight: rect.height,
startX: event.clientX,
startY: event.clientY,
currentEdge: edge,
};
};
/**
* 更新调整状态
* @param container - 容器元素
* @param edge - 边缘类型
* @param handle - 手柄元素
*/
const updateResizeState = (container: HTMLElement, edge: ResizeEdge, handle: HTMLElement) => {
isResizing.value = true;
activeEdge.value = edge;
element.value = container;
handle.style.backgroundColor = handleHoverColor;
};
/**
* 设置指针捕获
* @param handle - 手柄元素
* @param event - 指针事件
*/
const setupPointerCapture = (handle: HTMLElement, event: PointerEvent) => {
handle.setPointerCapture(event.pointerId);
handle.addEventListener('pointermove', handlePointerMove);
handle.addEventListener('pointerup', handlePointerUp);
};
/**
* 触发调整开始回调
* @param container - 容器元素
* @param edge - 边缘类型
* @param rect - 容器边界矩形
* @param event - 指针事件
*/
const triggerResizeStartCallback = (
container: HTMLElement,
edge: ResizeEdge,
rect: DOMRect,
event: PointerEvent,
) => {
const eventData: ResizeEventData = {
element: container,
edge,
width: rect.width,
height: rect.height,
startWidth: rect.width,
startHeight: rect.height,
startX: event.clientX,
startY: event.clientY,
currentX: event.clientX,
currentY: event.clientY,
originalEvent: event,
};
onResizeStart?.(eventData);
};
/**
* 指针移动处理
* @param event - 指针事件
*/
const handlePointerMove = (event: PointerEvent) => {
if (!isResizing.value || !resizeData) return;
event.preventDefault();
performPointerResize(event);
};
/**
* 指针释放处理
* @param event - 指针事件
*/
const handlePointerUp = (event: PointerEvent) => {
if (!isResizing.value || !resizeData) return;
const handle = event.target as HTMLElement;
if (!handle) return;
releasePointerCapture(handle, event);
restoreHandleStyle(handle);
stopResizeWithPointer(event);
};
/**
* 释放指针捕获
* @param handle - 手柄元素
* @param event - 指针事件
*/
const releasePointerCapture = (handle: HTMLElement, event: PointerEvent) => {
handle.releasePointerCapture(event.pointerId);
handle.removeEventListener('pointermove', handlePointerMove);
handle.removeEventListener('pointerup', handlePointerUp);
};
/**
* 恢复手柄样式
* @param handle - 手柄元素
*/
const restoreHandleStyle = (handle: HTMLElement) => {
handle.style.backgroundColor = handleColor;
};
// ==================== 尺寸计算 ====================
/**
* 计算浏览器视口边界
* @returns 视口宽高
*/
const getViewportBounds = () => ({
width: window.innerWidth || document.documentElement.clientWidth,
height: window.innerHeight || document.documentElement.clientHeight,
});
/**
* 计算容器的最大允许尺寸(考虑浏览器边界)
* @param container - 容器元素
* @param edge - 边缘类型
* @returns 最大宽度和高度
*/
const getMaxDimensions = (container: HTMLElement, edge: ResizeEdge) => {
if (!boundToViewport) {
return { maxWidth, maxHeight };
}
const rect = container.getBoundingClientRect();
const viewport = getViewportBounds();
let maxW = maxWidth;
let maxH = maxHeight;
// 计算最大宽度
if (edgeIncludesDirection(edge, EdgeDirection.Right)) {
const maxRightWidth = viewport.width - rect.left - safeMargin;
maxW = maxW !== undefined ? Math.min(maxW, maxRightWidth) : maxRightWidth;
} else if (edgeIncludesDirection(edge, EdgeDirection.Left)) {
const maxLeftWidth = rect.right - safeMargin;
maxW = maxW !== undefined ? Math.min(maxW, maxLeftWidth) : maxLeftWidth;
}
// 计算最大高度
if (edgeIncludesDirection(edge, EdgeDirection.Bottom)) {
const maxBottomHeight = viewport.height - rect.top - safeMargin;
maxH = maxH !== undefined ? Math.min(maxH, maxBottomHeight) : maxBottomHeight;
} else if (edgeIncludesDirection(edge, EdgeDirection.Top)) {
const maxTopHeight = rect.bottom - safeMargin;
maxH = maxH !== undefined ? Math.min(maxH, maxTopHeight) : maxTopHeight;
}
return { maxWidth: maxW, maxHeight: maxH };
};
/**
* 计算有效的最小尺寸
* @param originalSize - 原始尺寸
* @param minSize - 配置的最小尺寸
* @returns 有效的最小尺寸
*/
const getEffectiveMinSize = (originalSize: number, minSize: number): number => {
return allowShrink ? minSize : Math.max(minSize, originalSize);
};
// ==================== 尺寸调整 ====================
/**
* 执行调整大小
* @param event - 指针事件
*/
const performPointerResize = (event: PointerEvent) => {
const container = unref(el);
if (!container || !resizeData || originalWidth === null || originalHeight === null) return;
const { startWidth, startHeight, startX, startY, currentEdge } = resizeData;
// 计算有效的最小/最大尺寸
const effectiveMinWidth = getEffectiveMinSize(originalWidth, minWidth);
const effectiveMinHeight = getEffectiveMinSize(originalHeight, minHeight);
const { maxWidth: effectiveMaxWidth, maxHeight: effectiveMaxHeight } = getMaxDimensions(
container,
currentEdge,
);
// 计算新的尺寸
const { newWidth, newHeight } = calculateNewSize(
currentEdge,
startWidth,
startHeight,
event.clientX - startX,
event.clientY - startY,
effectiveMinWidth,
effectiveMinHeight,
effectiveMaxWidth,
effectiveMaxHeight,
);
// 应用新尺寸
applySize(container, newWidth, newHeight);
// 触发回调
triggerResizeCallback(
container,
currentEdge,
newWidth,
newHeight,
startWidth,
startHeight,
startX,
startY,
event,
);
};
/**
* 根据边缘和鼠标移动计算新的尺寸
* @param edge - 边缘类型
* @param startWidth - 起始宽度
* @param startHeight - 起始高度
* @param deltaX - X轴移动距离
* @param deltaY - Y轴移动距离
* @param minWidth - 最小宽度
* @param minHeight - 最小高度
* @param maxWidth - 最大宽度
* @param maxHeight - 最大高度
* @returns 新的宽度和高度
*/
const calculateNewSize = (
edge: ResizeEdge,
startWidth: number,
startHeight: number,
deltaX: number,
deltaY: number,
minWidth: number,
minHeight: number,
maxWidth?: number,
maxHeight?: number,
): { newWidth: number; newHeight: number } => {
let newWidth = startWidth;
let newHeight = startHeight;
// 计算宽度变化
if (edgeIncludesDirection(edge, EdgeDirection.Right)) {
newWidth = clamp(startWidth + deltaX, minWidth, maxWidth);
} else if (edgeIncludesDirection(edge, EdgeDirection.Left)) {
newWidth = clamp(startWidth - deltaX, minWidth, maxWidth);
}
// 计算高度变化
if (edgeIncludesDirection(edge, EdgeDirection.Bottom)) {
newHeight = clamp(startHeight + deltaY, minHeight, maxHeight);
} else if (edgeIncludesDirection(edge, EdgeDirection.Top)) {
newHeight = clamp(startHeight - deltaY, minHeight, maxHeight);
}
return { newWidth, newHeight };
};
/**
* 应用尺寸到容器
* @param container - 容器元素
* @param width - 新宽度
* @param height - 新高度
*/
const applySize = (container: HTMLElement, width: number, height: number) => {
container.style.width = `${width}px`;
container.style.height = `${height}px`;
};
/**
* 触发调整回调
* @param container - 容器元素
* @param edge - 边缘类型
* @param width - 新宽度
* @param height - 新高度
* @param startWidth - 起始宽度
* @param startHeight - 起始高度
* @param startX - 起始X坐标
* @param startY - 起始Y坐标
* @param event - 原始事件
*/
const triggerResizeCallback = (
container: HTMLElement,
edge: ResizeEdge,
width: number,
height: number,
startWidth: number,
startHeight: number,
startX: number,
startY: number,
event: PointerEvent,
) => {
const eventData: ResizeEventData = {
element: container,
edge,
width,
height,
startWidth,
startHeight,
startX,
startY,
currentX: event.clientX,
currentY: event.clientY,
originalEvent: event,
};
onResize?.(eventData);
};
// ==================== 状态管理 ====================
/**
* 停止调整大小
* @param event - 指针事件
*/
const stopResizeWithPointer = (event: PointerEvent) => {
if (!isResizing.value || !resizeData) return;
const container = unref(el);
if (!container) return;
const { startWidth, startHeight, startX, startY, currentEdge } = resizeData;
const rect = container.getBoundingClientRect();
// 触发结束回调
const eventData: ResizeEventData = {
element: container,
edge: currentEdge,
width: rect.width,
height: rect.height,
startWidth,
startHeight,
startX,
startY,
currentX: event.clientX,
currentY: event.clientY,
originalEvent: event,
};
onResizeEnd?.(eventData);
cleanupResizeState();
};
/**
* 清理调整状态
*/
const cleanupResizeState = () => {
isResizing.value = false;
activeEdge.value = null;
resizeData = null;
};
/**
* 停止调整大小(手动调用)
*/
const stopResize = () => {
if (!isResizing.value) return;
cleanupResizeState();
};
/**
* 销毁
*/
const destroy = () => {
stopResize();
clearHandles();
};
// ==================== 初始化 ====================
/**
* 重置原始尺寸
*/
const resetOriginalSize = () => {
originalWidth = null;
originalHeight = null;
};
/**
* 执行初始化(创建手柄)
*/
const doInit = () => {
const container = unref(el);
if (!container) {
console.warn('[useResizeable] 元素不存在,无法初始化');
return;
}
if (isInitialized.value) return;
resetOriginalSize();
createHandles();
isInitialized.value = true;
};
/**
* 初始化元素监听
*/
const initializeElementWatch = () => {
if (el && isRef(el)) {
// Ref 类型
watch(
el,
(newEl) => {
if (newEl) {
element.value = newEl;
doInit();
}
},
{ immediate: true },
);
} else if (el) {
// HTMLElement 类型
element.value = el as HTMLElement;
// 延迟创建手柄,确保元素已挂载
setTimeout(() => {
doInit();
}, 0);
}
};
// 初始化元素监听
immediate && initializeElementWatch();
// 组件卸载时清理
onUnmounted(() => {
destroy();
});
return {
isResizing,
activeEdge,
element,
init: initializeElementWatch,
stopResize,
destroy,
};
}
/**
* 可调整容器大小的 Hook(简化版,自动创建元素引用)
* @param options - 配置选项
* @returns 设置和状态对象
*/
export function useResizeableContainer(options: UseResizeableOptions = {}) {
const elementRef = ref<HTMLElement | null>(null);
const { isResizing, activeEdge, element, init, stopResize, destroy } = useResizeable(
elementRef,
options,
);
return {
elementRef,
isResizing,
activeEdge,
element,
init,
stopResize,
destroy,
};
}