1 | function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
2 |
|
3 | function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 |
|
14 |
|
15 |
|
16 | var gsap,
|
17 | _coreInitted,
|
18 | _clamp,
|
19 | _win,
|
20 | _doc,
|
21 | _docEl,
|
22 | _body,
|
23 | _isTouch,
|
24 | _pointerType,
|
25 | ScrollTrigger,
|
26 | _root,
|
27 | _normalizer,
|
28 | _eventTypes,
|
29 | _getGSAP = function _getGSAP() {
|
30 | return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
|
31 | },
|
32 | _passThrough = function _passThrough(p) {
|
33 | return p;
|
34 | },
|
35 | _startup = 1,
|
36 | _observers = [],
|
37 | _scrollers = [],
|
38 | _proxies = [],
|
39 | _getTime = Date.now,
|
40 | _bridge = function _bridge(name, value) {
|
41 | return value;
|
42 | },
|
43 | _integrate = function _integrate() {
|
44 | var core = ScrollTrigger.core,
|
45 | data = core.bridge || {},
|
46 | scrollers = core._scrollers,
|
47 | proxies = core._proxies;
|
48 | scrollers.push.apply(scrollers, _scrollers);
|
49 | proxies.push.apply(proxies, _proxies);
|
50 | _scrollers = scrollers;
|
51 | _proxies = proxies;
|
52 |
|
53 | _bridge = function _bridge(name, value) {
|
54 | return data[name](value);
|
55 | };
|
56 | },
|
57 | _getProxyProp = function _getProxyProp(element, property) {
|
58 | return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];
|
59 | },
|
60 | _isViewport = function _isViewport(el) {
|
61 | return !!~_root.indexOf(el);
|
62 | },
|
63 | _addListener = function _addListener(element, type, func, nonPassive, capture) {
|
64 | return element.addEventListener(type, func, {
|
65 | passive: !nonPassive,
|
66 | capture: !!capture
|
67 | });
|
68 | },
|
69 | _removeListener = function _removeListener(element, type, func) {
|
70 | return element.removeEventListener(type, func);
|
71 | },
|
72 | _scrollLeft = "scrollLeft",
|
73 | _scrollTop = "scrollTop",
|
74 | _onScroll = function _onScroll() {
|
75 | return _normalizer && _normalizer.isPressed || _scrollers.cache++;
|
76 | },
|
77 | _scrollCacheFunc = function _scrollCacheFunc(f) {
|
78 | return function (value) {
|
79 |
|
80 | if (value || value === 0) {
|
81 | _startup && (_win.history.scrollRestoration = "manual");
|
82 |
|
83 |
|
84 | f(value);
|
85 | f.v = value;
|
86 | f.c = _scrollers.cache;
|
87 | _normalizer && _normalizer.isPressed && _bridge("ss", value);
|
88 | } else if (_scrollers.cache !== f.c || _bridge("ref")) {
|
89 | f.c = _scrollers.cache;
|
90 | f.v = f();
|
91 | }
|
92 |
|
93 | return f.v;
|
94 | };
|
95 | },
|
96 | _horizontal = {
|
97 | s: _scrollLeft,
|
98 | p: "left",
|
99 | p2: "Left",
|
100 | os: "right",
|
101 | os2: "Right",
|
102 | d: "width",
|
103 | d2: "Width",
|
104 | a: "x",
|
105 | sc: _scrollCacheFunc(function (value) {
|
106 | return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
|
107 | })
|
108 | },
|
109 | _vertical = {
|
110 | s: _scrollTop,
|
111 | p: "top",
|
112 | p2: "Top",
|
113 | os: "bottom",
|
114 | os2: "Bottom",
|
115 | d: "height",
|
116 | d2: "Height",
|
117 | a: "y",
|
118 | op: _horizontal,
|
119 | sc: _scrollCacheFunc(function (value) {
|
120 | return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
|
121 | })
|
122 | },
|
123 | _getTarget = function _getTarget(t) {
|
124 | return gsap.utils.toArray(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
|
125 | },
|
126 | _getScrollFunc = function _getScrollFunc(element, _ref) {
|
127 | var s = _ref.s,
|
128 | sc = _ref.sc;
|
129 |
|
130 |
|
131 | var i = _scrollers.indexOf(element),
|
132 | offset = sc === _vertical.sc ? 1 : 2;
|
133 |
|
134 | !~i && (i = _scrollers.push(element) - 1);
|
135 | return _scrollers[i + offset] || (_scrollers[i + offset] = _getProxyProp(element, s) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
|
136 | return arguments.length ? element[s] = value : element[s];
|
137 | })));
|
138 | },
|
139 | _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
|
140 | var v1 = value,
|
141 | v2 = value,
|
142 | t1 = _getTime(),
|
143 | t2 = t1,
|
144 | min = minTimeRefresh || 50,
|
145 | dropToZeroTime = Math.max(500, min * 3),
|
146 | update = function update(value, force) {
|
147 | var t = _getTime();
|
148 |
|
149 | if (force || t - t1 > min) {
|
150 | v2 = v1;
|
151 | v1 = value;
|
152 | t2 = t1;
|
153 | t1 = t;
|
154 | } else if (useDelta) {
|
155 | v1 += value;
|
156 | } else {
|
157 |
|
158 | v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
|
159 | }
|
160 | },
|
161 | reset = function reset() {
|
162 | v2 = v1 = useDelta ? 0 : v1;
|
163 | t2 = t1 = 0;
|
164 | },
|
165 | getVelocity = function getVelocity(latestValue) {
|
166 | var tOld = t2,
|
167 | vOld = v2,
|
168 | t = _getTime();
|
169 |
|
170 | (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
|
171 | return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
|
172 | };
|
173 |
|
174 | return {
|
175 | update: update,
|
176 | reset: reset,
|
177 | getVelocity: getVelocity
|
178 | };
|
179 | },
|
180 | _getEvent = function _getEvent(e, preventDefault) {
|
181 | preventDefault && !e._gsapAllow && e.preventDefault();
|
182 | return e.changedTouches ? e.changedTouches[0] : e;
|
183 | },
|
184 | _getAbsoluteMax = function _getAbsoluteMax(a) {
|
185 | var max = Math.max.apply(Math, a),
|
186 | min = Math.min.apply(Math, a);
|
187 | return Math.abs(max) >= Math.abs(min) ? max : min;
|
188 | },
|
189 | _setScrollTrigger = function _setScrollTrigger() {
|
190 | ScrollTrigger = gsap.core.globals().ScrollTrigger;
|
191 | ScrollTrigger && ScrollTrigger.core && _integrate();
|
192 | },
|
193 | _initCore = function _initCore(core) {
|
194 | gsap = core || _getGSAP();
|
195 |
|
196 | if (gsap && typeof document !== "undefined" && document.body) {
|
197 | _win = window;
|
198 | _doc = document;
|
199 | _docEl = _doc.documentElement;
|
200 | _body = _doc.body;
|
201 | _root = [_win, _doc, _docEl, _body];
|
202 | _clamp = gsap.utils.clamp;
|
203 | _pointerType = "onpointerenter" in _body ? "pointer" : "mouse";
|
204 |
|
205 | _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
|
206 | _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
|
207 | setTimeout(function () {
|
208 | return _startup = 0;
|
209 | }, 500);
|
210 |
|
211 | _setScrollTrigger();
|
212 |
|
213 | _coreInitted = 1;
|
214 | }
|
215 |
|
216 | return _coreInitted;
|
217 | };
|
218 |
|
219 | _horizontal.op = _vertical;
|
220 | _scrollers.cache = 0;
|
221 | export var Observer = function () {
|
222 | function Observer(vars) {
|
223 | this.init(vars);
|
224 | }
|
225 |
|
226 | var _proto = Observer.prototype;
|
227 |
|
228 | _proto.init = function init(vars) {
|
229 | _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
|
230 | ScrollTrigger || _setScrollTrigger();
|
231 | var tolerance = vars.tolerance,
|
232 | dragMinimum = vars.dragMinimum,
|
233 | type = vars.type,
|
234 | target = vars.target,
|
235 | lineHeight = vars.lineHeight,
|
236 | debounce = vars.debounce,
|
237 | preventDefault = vars.preventDefault,
|
238 | onStop = vars.onStop,
|
239 | onStopDelay = vars.onStopDelay,
|
240 | ignore = vars.ignore,
|
241 | wheelSpeed = vars.wheelSpeed,
|
242 | event = vars.event,
|
243 | onDragStart = vars.onDragStart,
|
244 | onDragEnd = vars.onDragEnd,
|
245 | onDrag = vars.onDrag,
|
246 | onPress = vars.onPress,
|
247 | onRelease = vars.onRelease,
|
248 | onRight = vars.onRight,
|
249 | onLeft = vars.onLeft,
|
250 | onUp = vars.onUp,
|
251 | onDown = vars.onDown,
|
252 | onChangeX = vars.onChangeX,
|
253 | onChangeY = vars.onChangeY,
|
254 | onChange = vars.onChange,
|
255 | onToggleX = vars.onToggleX,
|
256 | onToggleY = vars.onToggleY,
|
257 | onHover = vars.onHover,
|
258 | onHoverEnd = vars.onHoverEnd,
|
259 | onMove = vars.onMove,
|
260 | ignoreCheck = vars.ignoreCheck,
|
261 | isNormalizer = vars.isNormalizer,
|
262 | onGestureStart = vars.onGestureStart,
|
263 | onGestureEnd = vars.onGestureEnd,
|
264 | onWheel = vars.onWheel,
|
265 | onEnable = vars.onEnable,
|
266 | onDisable = vars.onDisable,
|
267 | onClick = vars.onClick,
|
268 | scrollSpeed = vars.scrollSpeed,
|
269 | capture = vars.capture,
|
270 | allowClicks = vars.allowClicks,
|
271 | lockAxis = vars.lockAxis,
|
272 | onLockAxis = vars.onLockAxis;
|
273 | this.target = target = _getTarget(target) || _docEl;
|
274 | this.vars = vars;
|
275 | ignore && (ignore = gsap.utils.toArray(ignore));
|
276 | tolerance = tolerance || 0;
|
277 | dragMinimum = dragMinimum || 0;
|
278 | wheelSpeed = wheelSpeed || 1;
|
279 | scrollSpeed = scrollSpeed || 1;
|
280 | type = type || "wheel,touch,pointer";
|
281 | debounce = debounce !== false;
|
282 | lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22);
|
283 |
|
284 | var id,
|
285 | onStopDelayedCall,
|
286 | dragged,
|
287 | moved,
|
288 | wheeled,
|
289 | locked,
|
290 | axis,
|
291 | self = this,
|
292 | prevDeltaX = 0,
|
293 | prevDeltaY = 0,
|
294 | scrollFuncX = _getScrollFunc(target, _horizontal),
|
295 | scrollFuncY = _getScrollFunc(target, _vertical),
|
296 | scrollX = scrollFuncX(),
|
297 | scrollY = scrollFuncY(),
|
298 | limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
|
299 |
|
300 | isViewport = _isViewport(target),
|
301 | ownerDoc = target.ownerDocument || _doc,
|
302 | deltaX = [0, 0, 0],
|
303 |
|
304 | deltaY = [0, 0, 0],
|
305 | onClickTime = 0,
|
306 | clickCapture = function clickCapture() {
|
307 | return onClickTime = _getTime();
|
308 | },
|
309 | _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
|
310 | return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
|
311 | },
|
312 | onStopFunc = function onStopFunc() {
|
313 | self._vx.reset();
|
314 |
|
315 | self._vy.reset();
|
316 |
|
317 | onStopDelayedCall.pause();
|
318 | onStop && onStop(self);
|
319 | },
|
320 | update = function update() {
|
321 | var dx = self.deltaX = _getAbsoluteMax(deltaX),
|
322 | dy = self.deltaY = _getAbsoluteMax(deltaY),
|
323 | changedX = Math.abs(dx) >= tolerance,
|
324 | changedY = Math.abs(dy) >= tolerance;
|
325 |
|
326 | onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY);
|
327 |
|
328 | if (changedX) {
|
329 | onRight && self.deltaX > 0 && onRight(self);
|
330 | onLeft && self.deltaX < 0 && onLeft(self);
|
331 | onChangeX && onChangeX(self);
|
332 | onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
|
333 | prevDeltaX = self.deltaX;
|
334 | deltaX[0] = deltaX[1] = deltaX[2] = 0;
|
335 | }
|
336 |
|
337 | if (changedY) {
|
338 | onDown && self.deltaY > 0 && onDown(self);
|
339 | onUp && self.deltaY < 0 && onUp(self);
|
340 | onChangeY && onChangeY(self);
|
341 | onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
|
342 | prevDeltaY = self.deltaY;
|
343 | deltaY[0] = deltaY[1] = deltaY[2] = 0;
|
344 | }
|
345 |
|
346 | if (moved || dragged) {
|
347 | onMove && onMove(self);
|
348 | onLockAxis && locked && onLockAxis(self);
|
349 |
|
350 | if (dragged) {
|
351 | onDrag(self);
|
352 | dragged = false;
|
353 | }
|
354 |
|
355 | moved = locked = false;
|
356 | }
|
357 |
|
358 | if (wheeled) {
|
359 | onWheel(self);
|
360 | wheeled = false;
|
361 | }
|
362 |
|
363 | id = 0;
|
364 | },
|
365 | onDelta = function onDelta(x, y, index) {
|
366 | deltaX[index] += x;
|
367 | deltaY[index] += y;
|
368 |
|
369 | self._vx.update(x);
|
370 |
|
371 | self._vy.update(y);
|
372 |
|
373 | debounce ? id || (id = requestAnimationFrame(update)) : update();
|
374 | },
|
375 | onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
|
376 | if (axis !== "y") {
|
377 | deltaX[2] += x;
|
378 |
|
379 | self._vx.update(x, true);
|
380 |
|
381 | }
|
382 |
|
383 | if (axis !== "x") {
|
384 | deltaY[2] += y;
|
385 |
|
386 | self._vy.update(y, true);
|
387 | }
|
388 |
|
389 | if (lockAxis && !axis) {
|
390 | self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
|
391 | locked = true;
|
392 | }
|
393 |
|
394 | debounce ? id || (id = requestAnimationFrame(update)) : update();
|
395 | },
|
396 | _onDrag = function _onDrag(e) {
|
397 | if (_ignoreCheck(e, 1)) {
|
398 | return;
|
399 | }
|
400 |
|
401 | e = _getEvent(e, preventDefault);
|
402 | var x = e.clientX,
|
403 | y = e.clientY,
|
404 | dx = x - self.x,
|
405 | dy = y - self.y,
|
406 | isDragging = self.isDragging;
|
407 | self.x = x;
|
408 | self.y = y;
|
409 |
|
410 | if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) {
|
411 | onDrag && (dragged = true);
|
412 | isDragging || (self.isDragging = true);
|
413 | onTouchOrPointerDelta(dx, dy);
|
414 | isDragging || onDragStart && onDragStart(self);
|
415 | }
|
416 | },
|
417 | _onPress = self.onPress = function (e) {
|
418 | if (_ignoreCheck(e, 1)) {
|
419 | return;
|
420 | }
|
421 |
|
422 | self.axis = axis = null;
|
423 | onStopDelayedCall.pause();
|
424 | self.isPressed = true;
|
425 | e = _getEvent(e);
|
426 |
|
427 | prevDeltaX = prevDeltaY = 0;
|
428 | self.startX = self.x = e.clientX;
|
429 | self.startY = self.y = e.clientY;
|
430 |
|
431 | self._vx.reset();
|
432 |
|
433 |
|
434 | self._vy.reset();
|
435 |
|
436 | _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, preventDefault, capture);
|
437 |
|
438 | self.deltaX = self.deltaY = 0;
|
439 | onPress && onPress(self);
|
440 | },
|
441 | _onRelease = function _onRelease(e) {
|
442 | if (_ignoreCheck(e, 1)) {
|
443 | return;
|
444 | }
|
445 |
|
446 | _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag);
|
447 |
|
448 | var wasDragging = self.isDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
|
449 |
|
450 | eventData = _getEvent(e);
|
451 |
|
452 | if (!wasDragging) {
|
453 | self._vx.reset();
|
454 |
|
455 | self._vy.reset();
|
456 |
|
457 | if (preventDefault && allowClicks) {
|
458 | gsap.delayedCall(0.05, function () {
|
459 |
|
460 | if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
|
461 | if (e.target.click) {
|
462 |
|
463 | e.target.click();
|
464 | } else if (ownerDoc.createEvent) {
|
465 | var syntheticEvent = ownerDoc.createEvent("MouseEvents");
|
466 | syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
|
467 | e.target.dispatchEvent(syntheticEvent);
|
468 | }
|
469 | }
|
470 | });
|
471 | }
|
472 | }
|
473 |
|
474 | self.isDragging = self.isGesturing = self.isPressed = false;
|
475 | onStop && !isNormalizer && onStopDelayedCall.restart(true);
|
476 | onDragEnd && wasDragging && onDragEnd(self);
|
477 | onRelease && onRelease(self, wasDragging);
|
478 | },
|
479 | _onGestureStart = function _onGestureStart(e) {
|
480 | return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
|
481 | },
|
482 | _onGestureEnd = function _onGestureEnd() {
|
483 | return (self.isGesturing = false) || onGestureEnd(self);
|
484 | },
|
485 | onScroll = function onScroll(e) {
|
486 | if (_ignoreCheck(e)) {
|
487 | return;
|
488 | }
|
489 |
|
490 | var x = scrollFuncX(),
|
491 | y = scrollFuncY();
|
492 | onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
|
493 | scrollX = x;
|
494 | scrollY = y;
|
495 | onStop && onStopDelayedCall.restart(true);
|
496 | },
|
497 | _onWheel = function _onWheel(e) {
|
498 | if (_ignoreCheck(e)) {
|
499 | return;
|
500 | }
|
501 |
|
502 | e = _getEvent(e, preventDefault);
|
503 | onWheel && (wheeled = true);
|
504 | var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
|
505 | onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
|
506 | onStop && !isNormalizer && onStopDelayedCall.restart(true);
|
507 | },
|
508 | _onMove = function _onMove(e) {
|
509 | if (_ignoreCheck(e)) {
|
510 | return;
|
511 | }
|
512 |
|
513 | var x = e.clientX,
|
514 | y = e.clientY,
|
515 | dx = x - self.x,
|
516 | dy = y - self.y;
|
517 | self.x = x;
|
518 | self.y = y;
|
519 | moved = true;
|
520 | (dx || dy) && onTouchOrPointerDelta(dx, dy);
|
521 | },
|
522 | _onHover = function _onHover(e) {
|
523 | self.event = e;
|
524 | onHover(self);
|
525 | },
|
526 | _onHoverEnd = function _onHoverEnd(e) {
|
527 | self.event = e;
|
528 | onHoverEnd(self);
|
529 | },
|
530 | _onClick = function _onClick(e) {
|
531 | return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
|
532 | };
|
533 |
|
534 | onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
|
535 | self.deltaX = self.deltaY = 0;
|
536 | self._vx = _getVelocityProp(0, 50, true);
|
537 | self._vy = _getVelocityProp(0, 50, true);
|
538 | self.scrollX = scrollFuncX;
|
539 | self.scrollY = scrollFuncY;
|
540 | self.isDragging = self.isGesturing = self.isPressed = false;
|
541 |
|
542 | self.enable = function (e) {
|
543 | if (!self.isEnabled) {
|
544 | _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
|
545 |
|
546 | type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, preventDefault, capture);
|
547 | type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, preventDefault, capture);
|
548 |
|
549 | if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
|
550 | _addListener(target, _eventTypes[0], _onPress, preventDefault, capture);
|
551 |
|
552 | _addListener(ownerDoc, _eventTypes[2], _onRelease);
|
553 |
|
554 | _addListener(ownerDoc, _eventTypes[3], _onRelease);
|
555 |
|
556 | allowClicks && _addListener(target, "click", clickCapture, false, true);
|
557 | onClick && _addListener(target, "click", _onClick);
|
558 | onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
|
559 | onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
|
560 | onHover && _addListener(target, _pointerType + "enter", _onHover);
|
561 | onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
|
562 | onMove && _addListener(target, _pointerType + "move", _onMove);
|
563 | }
|
564 |
|
565 | self.isEnabled = true;
|
566 | e && e.type && _onPress(e);
|
567 | onEnable && onEnable(self);
|
568 | }
|
569 |
|
570 | return self;
|
571 | };
|
572 |
|
573 | self.disable = function () {
|
574 | if (self.isEnabled) {
|
575 |
|
576 | _observers.filter(function (o) {
|
577 | return o !== self && _isViewport(o.target);
|
578 | }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
|
579 |
|
580 | if (self.isPressed) {
|
581 | self._vx.reset();
|
582 |
|
583 | self._vy.reset();
|
584 |
|
585 | _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag);
|
586 | }
|
587 |
|
588 | _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll);
|
589 |
|
590 | _removeListener(target, "wheel", _onWheel);
|
591 |
|
592 | _removeListener(target, _eventTypes[0], _onPress);
|
593 |
|
594 | _removeListener(ownerDoc, _eventTypes[2], _onRelease);
|
595 |
|
596 | _removeListener(ownerDoc, _eventTypes[3], _onRelease);
|
597 |
|
598 | _removeListener(target, "click", clickCapture);
|
599 |
|
600 | _removeListener(target, "click", _onClick);
|
601 |
|
602 | _removeListener(ownerDoc, "gesturestart", _onGestureStart);
|
603 |
|
604 | _removeListener(ownerDoc, "gestureend", _onGestureEnd);
|
605 |
|
606 | _removeListener(target, _pointerType + "enter", _onHover);
|
607 |
|
608 | _removeListener(target, _pointerType + "leave", _onHoverEnd);
|
609 |
|
610 | _removeListener(target, _pointerType + "move", _onMove);
|
611 |
|
612 | self.isEnabled = self.isPressed = self.isDragging = false;
|
613 | onDisable && onDisable(self);
|
614 | }
|
615 | };
|
616 |
|
617 | self.kill = function () {
|
618 | self.disable();
|
619 |
|
620 | var i = _observers.indexOf(self);
|
621 |
|
622 | i >= 0 && _observers.splice(i, 1);
|
623 | _normalizer === self && (_normalizer = 0);
|
624 | };
|
625 |
|
626 | _observers.push(self);
|
627 |
|
628 | isNormalizer && _isViewport(target) && (_normalizer = self);
|
629 | self.enable(event);
|
630 | };
|
631 |
|
632 | _createClass(Observer, [{
|
633 | key: "velocityX",
|
634 | get: function get() {
|
635 | return this._vx.getVelocity();
|
636 | }
|
637 | }, {
|
638 | key: "velocityY",
|
639 | get: function get() {
|
640 | return this._vy.getVelocity();
|
641 | }
|
642 | }]);
|
643 |
|
644 | return Observer;
|
645 | }();
|
646 | Observer.version = "3.10.3";
|
647 |
|
648 | Observer.create = function (vars) {
|
649 | return new Observer(vars);
|
650 | };
|
651 |
|
652 | Observer.register = _initCore;
|
653 |
|
654 | Observer.getAll = function () {
|
655 | return _observers.slice();
|
656 | };
|
657 |
|
658 | Observer.getById = function (id) {
|
659 | return _observers.filter(function (o) {
|
660 | return o.vars.id === id;
|
661 | })[0];
|
662 | };
|
663 |
|
664 | _getGSAP() && gsap.registerPlugin(Observer);
|
665 | export { Observer as default, _isViewport, _scrollers, _getScrollFunc, _getProxyProp, _proxies, _getVelocityProp, _vertical, _horizontal, _getTarget }; |
\ | No newline at end of file |