@universal-material/angular
Version:
This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 16.1.0.
78 lines • 14.2 kB
JavaScript
import { EMPTY, fromEvent, of, race, Subject, timer } from 'rxjs';
import { endWith, filter, takeUntil } from 'rxjs/operators';
import { getTransitionDurationMs } from './util';
import { runInZone } from '../util';
export const environment = {
animation: true,
transitionTimerDelayMs: 5,
};
const noopFn = () => { };
const { transitionTimerDelayMs } = environment;
const runningTransitions = new Map();
export const runTransition = (zone, element, startFn, options) => {
// Getting initial context from options
let context = options.context || {};
// Checking if there are already running transitions on the given element.
const running = runningTransitions.get(element);
if (running) {
switch (options.runningTransition) {
// If there is one running and we want for it to 'continue' to run, we have to cancel the new one.
// We're not emitting any values, but simply completing the observable (EMPTY).
case 'continue':
return EMPTY;
// If there is one running and we want for it to 'stop', we have to complete the running one.
// We're simply completing the running one and not emitting any values and merging newly provided context
// with the one coming from currently running transition.
case 'stop':
zone.run(() => running.transition$.complete());
context = Object.assign(running.context, context);
runningTransitions.delete(element);
}
}
// Running the start function
const endFn = startFn(element, options.animation, context) || noopFn;
// If 'prefer-reduced-motion' is enabled, the 'transition' will be set to 'none'.
// If animations are disabled, we have to emit a value and complete the observable
// In this case we have to call the end function, but can finish immediately by emitting a value,
// completing the observable and executing end functions synchronously.
if (!options.animation || window.getComputedStyle(element).transitionProperty === 'none') {
zone.run(() => endFn());
return of(undefined).pipe(runInZone(zone));
}
// Starting a new transition
const transition$ = new Subject();
const finishTransition$ = new Subject();
const stop$ = transition$.pipe(endWith(true));
runningTransitions.set(element, {
transition$,
complete: () => {
finishTransition$.next();
finishTransition$.complete();
},
context
});
const transitionDurationMs = getTransitionDurationMs(element);
// 1. We have to both listen for the 'transitionend' event and have a 'just-in-case' timer,
// because 'transitionend' event might not be fired in some browsers, if the transitioning
// element becomes invisible (ex. when scrolling, making browser tab inactive, etc.). The timer
// guarantees, that we'll release the DOM element and complete 'ngbRunTransition'.
// 2. We need to filter transition end events, because they might bubble from shorter transitions
// on inner DOM elements. We're only interested in the transition on the 'element' itself.
zone.runOutsideAngular(() => {
const transitionEnd$ = fromEvent(element, 'transitionend').pipe(takeUntil(stop$), filter(({ target }) => target === element));
const timer$ = timer(transitionDurationMs + transitionTimerDelayMs).pipe(takeUntil(stop$));
race(timer$, transitionEnd$, finishTransition$).pipe(takeUntil(stop$)).subscribe(() => {
runningTransitions.delete(element);
zone.run(() => {
endFn();
transition$.next();
transition$.complete();
});
});
});
return transition$.asObservable();
};
export const completeTransition = (element) => {
runningTransitions.get(element)?.complete();
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transition.js","sourceRoot":"","sources":["../../../../../../src/util/transition/transition.ts"],"names":[],"mappings":"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","sourcesContent":["import {NgZone} from '@angular/core';\r\nimport {EMPTY, fromEvent, Observable, of, race, Subject, timer} from 'rxjs';\r\nimport {endWith, filter, takeUntil} from 'rxjs/operators';\r\nimport {getTransitionDurationMs} from './util';\r\nimport {runInZone} from '../util';\r\n\r\nexport const environment = {\r\n  animation: true,\r\n  transitionTimerDelayMs: 5,\r\n};\r\n\r\nexport type TransitionStartFn<T = any> = (element: HTMLElement, animation: boolean, context: T) =>\r\n  TransitionEndFn | void;\r\nexport type TransitionEndFn = () => void;\r\n\r\nexport interface TransitionOptions<T> {\r\n  animation: boolean;\r\n  runningTransition: 'continue' | 'stop';\r\n  context?: T;\r\n}\r\n\r\nexport interface NgbTransitionCtx<T> {\r\n  transition$: Subject<any>;\r\n  complete: () => void;\r\n  context: T;\r\n}\r\n\r\nconst noopFn: TransitionEndFn = () => {};\r\n\r\nconst {transitionTimerDelayMs} = environment;\r\nconst runningTransitions = new Map<HTMLElement, NgbTransitionCtx<any>>();\r\n\r\nexport const runTransition =\r\n  <T>(zone: NgZone, element: HTMLElement, startFn: TransitionStartFn<T>, options: TransitionOptions<T>):\r\n    Observable<void> => {\r\n\r\n    // Getting initial context from options\r\n    let context = options.context || <T>{};\r\n\r\n    // Checking if there are already running transitions on the given element.\r\n    const running = runningTransitions.get(element);\r\n    if (running) {\r\n      switch (options.runningTransition) {\r\n        // If there is one running and we want for it to 'continue' to run, we have to cancel the new one.\r\n        // We're not emitting any values, but simply completing the observable (EMPTY).\r\n        case 'continue':\r\n          return EMPTY;\r\n        // If there is one running and we want for it to 'stop', we have to complete the running one.\r\n        // We're simply completing the running one and not emitting any values and merging newly provided context\r\n        // with the one coming from currently running transition.\r\n        case 'stop':\r\n          zone.run(() => running.transition$.complete());\r\n          context = Object.assign(running.context, context);\r\n          runningTransitions.delete(element);\r\n      }\r\n    }\r\n\r\n    // Running the start function\r\n    const endFn = startFn(element, options.animation, context) || noopFn;\r\n\r\n    // If 'prefer-reduced-motion' is enabled, the 'transition' will be set to 'none'.\r\n    // If animations are disabled, we have to emit a value and complete the observable\r\n    // In this case we have to call the end function, but can finish immediately by emitting a value,\r\n    // completing the observable and executing end functions synchronously.\r\n    if (!options.animation || window.getComputedStyle(element).transitionProperty === 'none') {\r\n      zone.run(() => endFn());\r\n      return of(undefined).pipe(runInZone(zone));\r\n    }\r\n\r\n    // Starting a new transition\r\n    const transition$ = new Subject<void>();\r\n    const finishTransition$ = new Subject<void>();\r\n    const stop$ = transition$.pipe(endWith(true));\r\n    runningTransitions.set(element, {\r\n      transition$,\r\n      complete: () => {\r\n        finishTransition$.next();\r\n        finishTransition$.complete();\r\n      },\r\n      context\r\n    });\r\n\r\n    const transitionDurationMs = getTransitionDurationMs(element);\r\n\r\n    // 1. We have to both listen for the 'transitionend' event and have a 'just-in-case' timer,\r\n    // because 'transitionend' event might not be fired in some browsers, if the transitioning\r\n    // element becomes invisible (ex. when scrolling, making browser tab inactive, etc.). The timer\r\n    // guarantees, that we'll release the DOM element and complete 'ngbRunTransition'.\r\n    // 2. We need to filter transition end events, because they might bubble from shorter transitions\r\n    // on inner DOM elements. We're only interested in the transition on the 'element' itself.\r\n    zone.runOutsideAngular(() => {\r\n      const transitionEnd$ =\r\n        fromEvent(element, 'transitionend').pipe(takeUntil(stop$), filter(({target}) => target === element));\r\n      const timer$ = timer(transitionDurationMs + transitionTimerDelayMs).pipe(takeUntil(stop$));\r\n\r\n      race(timer$, transitionEnd$, finishTransition$).pipe(takeUntil(stop$)).subscribe(() => {\r\n        runningTransitions.delete(element);\r\n        zone.run(() => {\r\n          endFn();\r\n          transition$.next();\r\n          transition$.complete();\r\n        });\r\n      });\r\n    });\r\n\r\n    return transition$.asObservable();\r\n  };\r\n\r\nexport const completeTransition = (element: HTMLElement) => {\r\n  runningTransitions.get(element) ?.complete();\r\n};\r\n"]}