1 | 'use strict';
|
2 |
|
3 | const ionicGlobal = require('./ionic-global-06f21c1a.js');
|
4 | const hardwareBackButton = require('./hardware-back-button-148ce546.js');
|
5 | const helpers = require('./helpers-d381ec4d.js');
|
6 |
|
7 | let lastId = 0;
|
8 | const activeAnimations = new WeakMap();
|
9 | const createController = (tagName) => {
|
10 | return {
|
11 | create(options) {
|
12 | return createOverlay(tagName, options);
|
13 | },
|
14 | dismiss(data, role, id) {
|
15 | return dismissOverlay(document, data, role, tagName, id);
|
16 | },
|
17 | async getTop() {
|
18 | return getOverlay(document, tagName);
|
19 | }
|
20 | };
|
21 | };
|
22 | const alertController = createController('ion-alert');
|
23 | const actionSheetController = createController('ion-action-sheet');
|
24 | const loadingController = createController('ion-loading');
|
25 | const modalController = createController('ion-modal');
|
26 | const pickerController = createController('ion-picker');
|
27 | const popoverController = createController('ion-popover');
|
28 | const toastController = createController('ion-toast');
|
29 | const prepareOverlay = (el) => {
|
30 |
|
31 | if (typeof document !== 'undefined') {
|
32 | connectListeners(document);
|
33 | }
|
34 | const overlayIndex = lastId++;
|
35 | el.overlayIndex = overlayIndex;
|
36 | if (!el.hasAttribute('id')) {
|
37 | el.id = `ion-overlay-${overlayIndex}`;
|
38 | }
|
39 | };
|
40 | const createOverlay = (tagName, opts) => {
|
41 |
|
42 | if (typeof customElements !== 'undefined') {
|
43 | return customElements.whenDefined(tagName).then(() => {
|
44 | const element = document.createElement(tagName);
|
45 | element.classList.add('overlay-hidden');
|
46 |
|
47 |
|
48 | Object.assign(element, opts);
|
49 |
|
50 | getAppRoot(document).appendChild(element);
|
51 | return new Promise(resolve => helpers.componentOnReady(element, resolve));
|
52 | });
|
53 | }
|
54 | return Promise.resolve();
|
55 | };
|
56 | const focusableQueryString = '[tabindex]:not([tabindex^="-"]), input:not([type=hidden]):not([tabindex^="-"]), textarea:not([tabindex^="-"]), button:not([tabindex^="-"]), select:not([tabindex^="-"]), .ion-focusable:not([tabindex^="-"])';
|
57 | const innerFocusableQueryString = 'input:not([type=hidden]), textarea, button, select';
|
58 | const focusFirstDescendant = (ref, overlay) => {
|
59 | let firstInput = ref.querySelector(focusableQueryString);
|
60 | const shadowRoot = firstInput && firstInput.shadowRoot;
|
61 | if (shadowRoot) {
|
62 |
|
63 | firstInput = shadowRoot.querySelector(innerFocusableQueryString) || firstInput;
|
64 | }
|
65 | if (firstInput) {
|
66 | firstInput.focus();
|
67 | }
|
68 | else {
|
69 |
|
70 | overlay.focus();
|
71 | }
|
72 | };
|
73 | const focusLastDescendant = (ref, overlay) => {
|
74 | const inputs = Array.from(ref.querySelectorAll(focusableQueryString));
|
75 | let lastInput = inputs.length > 0 ? inputs[inputs.length - 1] : null;
|
76 | const shadowRoot = lastInput && lastInput.shadowRoot;
|
77 | if (shadowRoot) {
|
78 |
|
79 | lastInput = shadowRoot.querySelector(innerFocusableQueryString) || lastInput;
|
80 | }
|
81 | if (lastInput) {
|
82 | lastInput.focus();
|
83 | }
|
84 | else {
|
85 |
|
86 | overlay.focus();
|
87 | }
|
88 | };
|
89 |
|
90 |
|
91 |
|
92 |
|
93 |
|
94 |
|
95 |
|
96 | const trapKeyboardFocus = (ev, doc) => {
|
97 | const lastOverlay = getOverlay(doc);
|
98 | const target = ev.target;
|
99 |
|
100 | if (!lastOverlay || !target) {
|
101 | return;
|
102 | }
|
103 | |
104 |
|
105 |
|
106 |
|
107 |
|
108 |
|
109 | if (lastOverlay === target) {
|
110 | lastOverlay.lastFocus = undefined;
|
111 | |
112 |
|
113 |
|
114 |
|
115 |
|
116 |
|
117 |
|
118 |
|
119 | }
|
120 | else {
|
121 | |
122 |
|
123 |
|
124 |
|
125 | const overlayRoot = helpers.getElementRoot(lastOverlay);
|
126 | if (!overlayRoot.contains(target)) {
|
127 | return;
|
128 | }
|
129 | const overlayWrapper = overlayRoot.querySelector('.ion-overlay-wrapper');
|
130 | if (!overlayWrapper) {
|
131 | return;
|
132 | }
|
133 | |
134 |
|
135 |
|
136 |
|
137 | if (overlayWrapper.contains(target)) {
|
138 | lastOverlay.lastFocus = target;
|
139 | }
|
140 | else {
|
141 | |
142 |
|
143 |
|
144 |
|
145 |
|
146 | |
147 |
|
148 |
|
149 |
|
150 |
|
151 |
|
152 |
|
153 | const lastFocus = lastOverlay.lastFocus;
|
154 |
|
155 | focusFirstDescendant(overlayWrapper, lastOverlay);
|
156 | |
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 |
|
163 |
|
164 |
|
165 | if (lastFocus === doc.activeElement) {
|
166 | focusLastDescendant(overlayWrapper, lastOverlay);
|
167 | }
|
168 | lastOverlay.lastFocus = doc.activeElement;
|
169 | }
|
170 | }
|
171 | };
|
172 | const connectListeners = (doc) => {
|
173 | if (lastId === 0) {
|
174 | lastId = 1;
|
175 | doc.addEventListener('focus', ev => trapKeyboardFocus(ev, doc), true);
|
176 |
|
177 | doc.addEventListener('ionBackButton', ev => {
|
178 | const lastOverlay = getOverlay(doc);
|
179 | if (lastOverlay && lastOverlay.backdropDismiss) {
|
180 | ev.detail.register(hardwareBackButton.OVERLAY_BACK_BUTTON_PRIORITY, () => {
|
181 | return lastOverlay.dismiss(undefined, BACKDROP);
|
182 | });
|
183 | }
|
184 | });
|
185 |
|
186 | doc.addEventListener('keyup', ev => {
|
187 | if (ev.key === 'Escape') {
|
188 | const lastOverlay = getOverlay(doc);
|
189 | if (lastOverlay && lastOverlay.backdropDismiss) {
|
190 | lastOverlay.dismiss(undefined, BACKDROP);
|
191 | }
|
192 | }
|
193 | });
|
194 | }
|
195 | };
|
196 | const dismissOverlay = (doc, data, role, overlayTag, id) => {
|
197 | const overlay = getOverlay(doc, overlayTag, id);
|
198 | if (!overlay) {
|
199 | return Promise.reject('overlay does not exist');
|
200 | }
|
201 | return overlay.dismiss(data, role);
|
202 | };
|
203 | const getOverlays = (doc, selector) => {
|
204 | if (selector === undefined) {
|
205 | selector = 'ion-alert,ion-action-sheet,ion-loading,ion-modal,ion-picker,ion-popover,ion-toast';
|
206 | }
|
207 | return Array.from(doc.querySelectorAll(selector))
|
208 | .filter(c => c.overlayIndex > 0);
|
209 | };
|
210 | const getOverlay = (doc, overlayTag, id) => {
|
211 | const overlays = getOverlays(doc, overlayTag);
|
212 | return (id === undefined)
|
213 | ? overlays[overlays.length - 1]
|
214 | : overlays.find(o => o.id === id);
|
215 | };
|
216 |
|
217 |
|
218 |
|
219 |
|
220 |
|
221 |
|
222 |
|
223 |
|
224 |
|
225 |
|
226 |
|
227 |
|
228 |
|
229 |
|
230 |
|
231 |
|
232 |
|
233 |
|
234 |
|
235 |
|
236 |
|
237 |
|
238 | const setRootAriaHidden = (hidden = false) => {
|
239 | const root = getAppRoot(document);
|
240 | const viewContainer = root.querySelector('ion-router-outlet, ion-nav, #ion-view-container-root');
|
241 | if (!viewContainer) {
|
242 | return;
|
243 | }
|
244 | if (hidden) {
|
245 | viewContainer.setAttribute('aria-hidden', 'true');
|
246 | }
|
247 | else {
|
248 | viewContainer.removeAttribute('aria-hidden');
|
249 | }
|
250 | };
|
251 | const present = async (overlay, name, iosEnterAnimation, mdEnterAnimation, opts) => {
|
252 | if (overlay.presented) {
|
253 | return;
|
254 | }
|
255 | setRootAriaHidden(true);
|
256 | overlay.presented = true;
|
257 | overlay.willPresent.emit();
|
258 | const mode = ionicGlobal.getIonMode(overlay);
|
259 |
|
260 | const animationBuilder = (overlay.enterAnimation)
|
261 | ? overlay.enterAnimation
|
262 | : ionicGlobal.config.get(name, mode === 'ios' ? iosEnterAnimation : mdEnterAnimation);
|
263 | const completed = await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
|
264 | if (completed) {
|
265 | overlay.didPresent.emit();
|
266 | }
|
267 | |
268 |
|
269 |
|
270 |
|
271 |
|
272 |
|
273 |
|
274 |
|
275 | if (overlay.el.tagName !== 'ION-TOAST') {
|
276 | focusPreviousElementOnDismiss(overlay.el);
|
277 | }
|
278 | if (overlay.keyboardClose) {
|
279 | overlay.el.focus();
|
280 | }
|
281 | };
|
282 |
|
283 |
|
284 |
|
285 |
|
286 |
|
287 |
|
288 |
|
289 |
|
290 |
|
291 |
|
292 | const focusPreviousElementOnDismiss = async (overlayEl) => {
|
293 | let previousElement = document.activeElement;
|
294 | if (!previousElement) {
|
295 | return;
|
296 | }
|
297 | const shadowRoot = previousElement && previousElement.shadowRoot;
|
298 | if (shadowRoot) {
|
299 |
|
300 | previousElement = shadowRoot.querySelector(innerFocusableQueryString) || previousElement;
|
301 | }
|
302 | await overlayEl.onDidDismiss();
|
303 | previousElement.focus();
|
304 | };
|
305 | const dismiss = async (overlay, data, role, name, iosLeaveAnimation, mdLeaveAnimation, opts) => {
|
306 | if (!overlay.presented) {
|
307 | return false;
|
308 | }
|
309 | setRootAriaHidden(false);
|
310 | overlay.presented = false;
|
311 | try {
|
312 |
|
313 | overlay.el.style.setProperty('pointer-events', 'none');
|
314 | overlay.willDismiss.emit({ data, role });
|
315 | const mode = ionicGlobal.getIonMode(overlay);
|
316 | const animationBuilder = (overlay.leaveAnimation)
|
317 | ? overlay.leaveAnimation
|
318 | : ionicGlobal.config.get(name, mode === 'ios' ? iosLeaveAnimation : mdLeaveAnimation);
|
319 |
|
320 | if (role !== 'gesture') {
|
321 | await overlayAnimation(overlay, animationBuilder, overlay.el, opts);
|
322 | }
|
323 | overlay.didDismiss.emit({ data, role });
|
324 | activeAnimations.delete(overlay);
|
325 | }
|
326 | catch (err) {
|
327 | console.error(err);
|
328 | }
|
329 | overlay.el.remove();
|
330 | return true;
|
331 | };
|
332 | const getAppRoot = (doc) => {
|
333 | return doc.querySelector('ion-app') || doc.body;
|
334 | };
|
335 | const overlayAnimation = async (overlay, animationBuilder, baseEl, opts) => {
|
336 |
|
337 | baseEl.classList.remove('overlay-hidden');
|
338 | const aniRoot = baseEl.shadowRoot || overlay.el;
|
339 | const animation = animationBuilder(aniRoot, opts);
|
340 | if (!overlay.animated || !ionicGlobal.config.getBoolean('animated', true)) {
|
341 | animation.duration(0);
|
342 | }
|
343 | if (overlay.keyboardClose) {
|
344 | animation.beforeAddWrite(() => {
|
345 | const activeElement = baseEl.ownerDocument.activeElement;
|
346 | if (activeElement && activeElement.matches('input, ion-input, ion-textarea')) {
|
347 | activeElement.blur();
|
348 | }
|
349 | });
|
350 | }
|
351 | const activeAni = activeAnimations.get(overlay) || [];
|
352 | activeAnimations.set(overlay, [...activeAni, animation]);
|
353 | await animation.play();
|
354 | return true;
|
355 | };
|
356 | const eventMethod = (element, eventName) => {
|
357 | let resolve;
|
358 | const promise = new Promise(r => resolve = r);
|
359 | onceEvent(element, eventName, (event) => {
|
360 | resolve(event.detail);
|
361 | });
|
362 | return promise;
|
363 | };
|
364 | const onceEvent = (element, eventName, callback) => {
|
365 | const handler = (ev) => {
|
366 | helpers.removeEventListener(element, eventName, handler);
|
367 | callback(ev);
|
368 | };
|
369 | helpers.addEventListener(element, eventName, handler);
|
370 | };
|
371 | const isCancel = (role) => {
|
372 | return role === 'cancel' || role === BACKDROP;
|
373 | };
|
374 | const defaultGate = (h) => h();
|
375 | const safeCall = (handler, arg) => {
|
376 | if (typeof handler === 'function') {
|
377 | const jmp = ionicGlobal.config.get('_zoneGate', defaultGate);
|
378 | return jmp(() => {
|
379 | try {
|
380 | return handler(arg);
|
381 | }
|
382 | catch (e) {
|
383 | console.error(e);
|
384 | }
|
385 | });
|
386 | }
|
387 | return undefined;
|
388 | };
|
389 | const BACKDROP = 'backdrop';
|
390 |
|
391 | exports.BACKDROP = BACKDROP;
|
392 | exports.actionSheetController = actionSheetController;
|
393 | exports.activeAnimations = activeAnimations;
|
394 | exports.alertController = alertController;
|
395 | exports.dismiss = dismiss;
|
396 | exports.eventMethod = eventMethod;
|
397 | exports.isCancel = isCancel;
|
398 | exports.loadingController = loadingController;
|
399 | exports.modalController = modalController;
|
400 | exports.pickerController = pickerController;
|
401 | exports.popoverController = popoverController;
|
402 | exports.prepareOverlay = prepareOverlay;
|
403 | exports.present = present;
|
404 | exports.safeCall = safeCall;
|
405 | exports.toastController = toastController;
|