File size: 6,258 Bytes
04f192c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
/**
 * SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

import type { MaybeRef } from "vue";
import {
  computed,
  isRef,
  nextTick,
  onActivated,
  onDeactivated,
  onMounted,
  onUnmounted,
  ref,
  shallowRef,
  unref,
  watch,
} from "vue";

type ScrollContainer = HTMLElement | null | undefined;

type UseCustomScrollOptions = {
  // top offset: determine "arrived" when approaching threshold
  offsetTop?: number;

  // bottom offset: determine "arrived" when approaching threshold
  offsetBottom?: number;

  // behavior of window.scrollTo
  behavior?: ScrollBehavior;

  // whether event listener is passive (recommended true for performance)
  passive?: boolean;

  /**
   * scroll event throttling:
   * - 'raf': merge with requestAnimationFrame
   * - number: throttle with timer in milliseconds
   * - null: no throttling
   */
  throttle?: number | "frame" | null;

  // whether to re-measure on ResizeObserver changes
  measureOnResize?: boolean;
};

export function useCustomScroll(containerRef: MaybeRef<ScrollContainer>, options: UseCustomScrollOptions = {}) {
  const {
    offsetTop = 0,
    offsetBottom = 32,
    behavior = "smooth",
    passive = true,
    throttle = "frame",
    measureOnResize = true,
  } = options;

  // state
  const y = ref(0);
  const prevY = ref(0);
  const direction = computed<"up" | "down" | "none">(() => {
    if (y.value === prevY.value) return "none";
    return y.value > prevY.value ? "down" : "up";
  });

  const arrivedTop = ref(true);
  const arrivedBottom = ref(false);
  const isScrolling = ref(false);
  const scrollHeight = ref(0);
  const clientHeight = ref(0);

  // internals
  const cleanupFns: Array<() => void> = [];
  const ro = shallowRef<ResizeObserver | null>(null);
  let ticking = false;
  let throttleTimer: number | null = null;

  const _measureCore = (el: HTMLElement) => {
    const top = el.scrollTop;
    prevY.value = y.value;
    y.value = top;
    scrollHeight.value = el.scrollHeight;
    clientHeight.value = el.clientHeight;

    arrivedTop.value = top <= offsetTop;
    arrivedBottom.value = top + el.clientHeight >= el.scrollHeight - offsetBottom;
  };

  const measure = () => {
    const el = unref(containerRef);
    if (!el) return;
    _measureCore(el);
  };

  // throttled/frame scroll handler
  const handleScroll = () => {
    const el = unref(containerRef);
    if (!el) return;

    if (throttle === "frame") {
      if (ticking) return;
      ticking = true;
      requestAnimationFrame(() => {
        _measureCore(el);
        ticking = false;
      });
      return;
    }

    if (typeof throttle === "number" && throttle > 0) {
      if (throttleTimer != null) return;
      throttleTimer = window.setTimeout(() => {
        _measureCore(el);
        throttleTimer = null;
      }, throttle) as unknown as number;
      return;
    }

    _measureCore(el);
  };

  // scroll APIs
  const scrollTo = (top: number) => {
    const el = unref(containerRef);
    if (!el) return;
    el.scrollTo({ top, behavior });
  };

  const scrollBy = (delta: number) => {
    const el = unref(containerRef);
    if (!el) return;
    el.scrollTo({
      top: el.scrollTop + delta,
      behavior,
    });
  };

  const scrollToTop = () => scrollTo(0);

  const scrollToBottom = () => {
    const el = unref(containerRef);
    if (!el) return;
    el.scrollTo({
      top: el.scrollHeight - el.clientHeight,
      behavior,
    });
    // To ensure measurement is in post-scroll state, measure in next frame
    requestAnimationFrame(measure);

    // Additionally: delay once more to accommodate asynchronous content expansion
    setTimeout(measure, 0);
    setTimeout(measure, 50);

    // If you want to leave a bottom offset when scrolling to bottom, you can use:
    // el.scrollTo({ top: Math.max(0, el.scrollHeight - el.clientHeight - offsetBottom), behavior })
  };

  // ---- listeners setup/cleanup
  const setupScrollListener = (el: HTMLElement) => {
    el.addEventListener("scroll", onScroll, { passive: passive ?? true });
    cleanupFns.push(() => el.removeEventListener("scroll", onScroll));
  };

  const onScroll = (evt: Event) => {
    isScrolling.value = true;
    handleScroll();
    // Reset isScrolling at the end of a macro task, indicating this scroll cycle is complete (approximate)
    queueMicrotask(() => {
      isScrolling.value = false;
    });
  };

  const setupResizeObserver = (el: HTMLElement) => {
    if (!("ResizeObserver" in window) || !measureOnResize) return;
    const observer = new ResizeObserver(() => {
      // Re-measure when container size changes or content reflows
      measure();
    });
    observer.observe(el);
    ro.value = observer;
    cleanupFns.push(() => {
      observer.disconnect();
      ro.value = null;
    });
  };

  const setup = (el: HTMLElement) => {
    setupScrollListener(el);
    setupResizeObserver(el);
    // Initial measurement: first nextTick wait for DOM stable, then measure + add another frame
    nextTick(() => {
      measure();
      requestAnimationFrame(measure);
    });
  };

  const cleanup = () => {
    cleanupFns.splice(0).forEach((fn) => {
      try {
        fn();
      } catch {}
    });
    if (throttleTimer != null) {
      clearTimeout(throttleTimer);
      throttleTimer = null;
    }
    ticking = false;
  };

  // ---- lifecycle
  onMounted(() => {
    const el = unref(containerRef);
    if (el) setup(el as HTMLElement);
  });

  onUnmounted(() => {
    cleanup();
  });

  // Support keep-alive: re-measure on activation to avoid inaccurate status due to size/content changes
  onActivated(() => {
    requestAnimationFrame(measure);
  });
  onDeactivated(() => {
    // Process as needed
  });

  // Rebind when container reference changes
  if (isRef(containerRef)) {
    watch(
      containerRef,
      (el, oldEl) => {
        if (oldEl) cleanup();
        if (el) setup(el as HTMLElement);
      },
      { flush: "post" },
    );
  }

  return {
    // state
    y,
    direction,
    arrivedTop,
    arrivedBottom,
    isScrolling,
    scrollHeight,
    clientHeight,

    // actions
    measure,
    scrollTo,
    scrollBy,
    scrollToTop,
    scrollToBottom,
  };
}