You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
373 lines
16 KiB
373 lines
16 KiB
import * as i0 from '@angular/core';
|
|
import { Injectable, Inject, PLATFORM_ID, NgModule } from '@angular/core';
|
|
import { isPlatformBrowser } from '@angular/common';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
// Whether the current platform supports the V8 Break Iterator. The V8 check
|
|
// is necessary to detect all Blink based browsers.
|
|
import * as ɵngcc0 from '@angular/core';
|
|
let hasV8BreakIterator;
|
|
// We need a try/catch around the reference to `Intl`, because accessing it in some cases can
|
|
// cause IE to throw. These cases are tied to particular versions of Windows and can happen if
|
|
// the consumer is providing a polyfilled `Map`. See:
|
|
// https://github.com/Microsoft/ChakraCore/issues/3189
|
|
// https://github.com/angular/components/issues/15687
|
|
try {
|
|
hasV8BreakIterator = (typeof Intl !== 'undefined' && Intl.v8BreakIterator);
|
|
}
|
|
catch (_a) {
|
|
hasV8BreakIterator = false;
|
|
}
|
|
/**
|
|
* Service to detect the current platform by comparing the userAgent strings and
|
|
* checking browser-specific global properties.
|
|
*/
|
|
class Platform {
|
|
constructor(_platformId) {
|
|
this._platformId = _platformId;
|
|
// We want to use the Angular platform check because if the Document is shimmed
|
|
// without the navigator, the following checks will fail. This is preferred because
|
|
// sometimes the Document may be shimmed without the user's knowledge or intention
|
|
/** Whether the Angular application is being rendered in the browser. */
|
|
this.isBrowser = this._platformId ?
|
|
isPlatformBrowser(this._platformId) : typeof document === 'object' && !!document;
|
|
/** Whether the current browser is Microsoft Edge. */
|
|
this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);
|
|
/** Whether the current rendering engine is Microsoft Trident. */
|
|
this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);
|
|
// EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.
|
|
/** Whether the current rendering engine is Blink. */
|
|
this.BLINK = this.isBrowser && (!!(window.chrome || hasV8BreakIterator) &&
|
|
typeof CSS !== 'undefined' && !this.EDGE && !this.TRIDENT);
|
|
// Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to
|
|
// ensure that Webkit runs standalone and is not used as another engine's base.
|
|
/** Whether the current rendering engine is WebKit. */
|
|
this.WEBKIT = this.isBrowser &&
|
|
/AppleWebKit/i.test(navigator.userAgent) && !this.BLINK && !this.EDGE && !this.TRIDENT;
|
|
/** Whether the current platform is Apple iOS. */
|
|
this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) &&
|
|
!('MSStream' in window);
|
|
// It's difficult to detect the plain Gecko engine, because most of the browsers identify
|
|
// them self as Gecko-like browsers and modify the userAgent's according to that.
|
|
// Since we only cover one explicit Firefox case, we can simply check for Firefox
|
|
// instead of having an unstable check for Gecko.
|
|
/** Whether the current browser is Firefox. */
|
|
this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);
|
|
/** Whether the current platform is Android. */
|
|
// Trident on mobile adds the android platform to the userAgent to trick detections.
|
|
this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;
|
|
// Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake
|
|
// this and just place the Safari keyword in the userAgent. To be more safe about Safari every
|
|
// Safari browser should also use Webkit as its layout engine.
|
|
/** Whether the current browser is Safari. */
|
|
this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;
|
|
}
|
|
}
|
|
Platform.ɵfac = function Platform_Factory(t) { return new (t || Platform)(ɵngcc0.ɵɵinject(PLATFORM_ID)); };
|
|
Platform.ɵprov = i0.ɵɵdefineInjectable({ factory: function Platform_Factory() { return new Platform(i0.ɵɵinject(i0.PLATFORM_ID)); }, token: Platform, providedIn: "root" });
|
|
Platform.ctorParameters = () => [
|
|
{ type: Object, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
|
|
];
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(Platform, [{
|
|
type: Injectable,
|
|
args: [{ providedIn: 'root' }]
|
|
}], function () { return [{ type: Object, decorators: [{
|
|
type: Inject,
|
|
args: [PLATFORM_ID]
|
|
}] }]; }, null); })();
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
class PlatformModule {
|
|
}
|
|
PlatformModule.ɵfac = function PlatformModule_Factory(t) { return new (t || PlatformModule)(); };
|
|
PlatformModule.ɵmod = /*@__PURE__*/ ɵngcc0.ɵɵdefineNgModule({ type: PlatformModule });
|
|
PlatformModule.ɵinj = /*@__PURE__*/ ɵngcc0.ɵɵdefineInjector({});
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(PlatformModule, [{
|
|
type: NgModule,
|
|
args: [{}]
|
|
}], null, null); })();
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Cached result Set of input types support by the current browser. */
|
|
let supportedInputTypes;
|
|
/** Types of `<input>` that *might* be supported. */
|
|
const candidateInputTypes = [
|
|
// `color` must come first. Chrome 56 shows a warning if we change the type to `color` after
|
|
// first changing it to something else:
|
|
// The specified value "" does not conform to the required format.
|
|
// The format is "#rrggbb" where rr, gg, bb are two-digit hexadecimal numbers.
|
|
'color',
|
|
'button',
|
|
'checkbox',
|
|
'date',
|
|
'datetime-local',
|
|
'email',
|
|
'file',
|
|
'hidden',
|
|
'image',
|
|
'month',
|
|
'number',
|
|
'password',
|
|
'radio',
|
|
'range',
|
|
'reset',
|
|
'search',
|
|
'submit',
|
|
'tel',
|
|
'text',
|
|
'time',
|
|
'url',
|
|
'week',
|
|
];
|
|
/** @returns The input types supported by this browser. */
|
|
function getSupportedInputTypes() {
|
|
// Result is cached.
|
|
if (supportedInputTypes) {
|
|
return supportedInputTypes;
|
|
}
|
|
// We can't check if an input type is not supported until we're on the browser, so say that
|
|
// everything is supported when not on the browser. We don't use `Platform` here since it's
|
|
// just a helper function and can't inject it.
|
|
if (typeof document !== 'object' || !document) {
|
|
supportedInputTypes = new Set(candidateInputTypes);
|
|
return supportedInputTypes;
|
|
}
|
|
let featureTestInput = document.createElement('input');
|
|
supportedInputTypes = new Set(candidateInputTypes.filter(value => {
|
|
featureTestInput.setAttribute('type', value);
|
|
return featureTestInput.type === value;
|
|
}));
|
|
return supportedInputTypes;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Cached result of whether the user's browser supports passive event listeners. */
|
|
let supportsPassiveEvents;
|
|
/**
|
|
* Checks whether the user's browser supports passive event listeners.
|
|
* See: https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md
|
|
*/
|
|
function supportsPassiveEventListeners() {
|
|
if (supportsPassiveEvents == null && typeof window !== 'undefined') {
|
|
try {
|
|
window.addEventListener('test', null, Object.defineProperty({}, 'passive', {
|
|
get: () => supportsPassiveEvents = true
|
|
}));
|
|
}
|
|
finally {
|
|
supportsPassiveEvents = supportsPassiveEvents || false;
|
|
}
|
|
}
|
|
return supportsPassiveEvents;
|
|
}
|
|
/**
|
|
* Normalizes an `AddEventListener` object to something that can be passed
|
|
* to `addEventListener` on any browser, no matter whether it supports the
|
|
* `options` parameter.
|
|
* @param options Object to be normalized.
|
|
*/
|
|
function normalizePassiveListenerOptions(options) {
|
|
return supportsPassiveEventListeners() ? options : !!options.capture;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Cached result of the way the browser handles the horizontal scroll axis in RTL mode. */
|
|
let rtlScrollAxisType;
|
|
/** Cached result of the check that indicates whether the browser supports scroll behaviors. */
|
|
let scrollBehaviorSupported;
|
|
/** Check whether the browser supports scroll behaviors. */
|
|
function supportsScrollBehavior() {
|
|
if (scrollBehaviorSupported == null) {
|
|
// If we're not in the browser, it can't be supported. Also check for `Element`, because
|
|
// some projects stub out the global `document` during SSR which can throw us off.
|
|
if (typeof document !== 'object' || !document || typeof Element !== 'function' || !Element) {
|
|
scrollBehaviorSupported = false;
|
|
return scrollBehaviorSupported;
|
|
}
|
|
// If the element can have a `scrollBehavior` style, we can be sure that it's supported.
|
|
if ('scrollBehavior' in document.documentElement.style) {
|
|
scrollBehaviorSupported = true;
|
|
}
|
|
else {
|
|
// At this point we have 3 possibilities: `scrollTo` isn't supported at all, it's
|
|
// supported but it doesn't handle scroll behavior, or it has been polyfilled.
|
|
const scrollToFunction = Element.prototype.scrollTo;
|
|
if (scrollToFunction) {
|
|
// We can detect if the function has been polyfilled by calling `toString` on it. Native
|
|
// functions are obfuscated using `[native code]`, whereas if it was overwritten we'd get
|
|
// the actual function source. Via https://davidwalsh.name/detect-native-function. Consider
|
|
// polyfilled functions as supporting scroll behavior.
|
|
scrollBehaviorSupported = !/\{\s*\[native code\]\s*\}/.test(scrollToFunction.toString());
|
|
}
|
|
else {
|
|
scrollBehaviorSupported = false;
|
|
}
|
|
}
|
|
}
|
|
return scrollBehaviorSupported;
|
|
}
|
|
/**
|
|
* Checks the type of RTL scroll axis used by this browser. As of time of writing, Chrome is NORMAL,
|
|
* Firefox & Safari are NEGATED, and IE & Edge are INVERTED.
|
|
*/
|
|
function getRtlScrollAxisType() {
|
|
// We can't check unless we're on the browser. Just assume 'normal' if we're not.
|
|
if (typeof document !== 'object' || !document) {
|
|
return 0 /* NORMAL */;
|
|
}
|
|
if (rtlScrollAxisType == null) {
|
|
// Create a 1px wide scrolling container and a 2px wide content element.
|
|
const scrollContainer = document.createElement('div');
|
|
const containerStyle = scrollContainer.style;
|
|
scrollContainer.dir = 'rtl';
|
|
containerStyle.width = '1px';
|
|
containerStyle.overflow = 'auto';
|
|
containerStyle.visibility = 'hidden';
|
|
containerStyle.pointerEvents = 'none';
|
|
containerStyle.position = 'absolute';
|
|
const content = document.createElement('div');
|
|
const contentStyle = content.style;
|
|
contentStyle.width = '2px';
|
|
contentStyle.height = '1px';
|
|
scrollContainer.appendChild(content);
|
|
document.body.appendChild(scrollContainer);
|
|
rtlScrollAxisType = 0 /* NORMAL */;
|
|
// The viewport starts scrolled all the way to the right in RTL mode. If we are in a NORMAL
|
|
// browser this would mean that the scrollLeft should be 1. If it's zero instead we know we're
|
|
// dealing with one of the other two types of browsers.
|
|
if (scrollContainer.scrollLeft === 0) {
|
|
// In a NEGATED browser the scrollLeft is always somewhere in [-maxScrollAmount, 0]. For an
|
|
// INVERTED browser it is always somewhere in [0, maxScrollAmount]. We can determine which by
|
|
// setting to the scrollLeft to 1. This is past the max for a NEGATED browser, so it will
|
|
// return 0 when we read it again.
|
|
scrollContainer.scrollLeft = 1;
|
|
rtlScrollAxisType =
|
|
scrollContainer.scrollLeft === 0 ? 1 /* NEGATED */ : 2 /* INVERTED */;
|
|
}
|
|
scrollContainer.parentNode.removeChild(scrollContainer);
|
|
}
|
|
return rtlScrollAxisType;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
let shadowDomIsSupported;
|
|
/** Checks whether the user's browser support Shadow DOM. */
|
|
function _supportsShadowDom() {
|
|
if (shadowDomIsSupported == null) {
|
|
const head = typeof document !== 'undefined' ? document.head : null;
|
|
shadowDomIsSupported = !!(head && (head.createShadowRoot || head.attachShadow));
|
|
}
|
|
return shadowDomIsSupported;
|
|
}
|
|
/** Gets the shadow root of an element, if supported and the element is inside the Shadow DOM. */
|
|
function _getShadowRoot(element) {
|
|
if (_supportsShadowDom()) {
|
|
const rootNode = element.getRootNode ? element.getRootNode() : null;
|
|
// Note that this should be caught by `_supportsShadowDom`, but some
|
|
// teams have been able to hit this code path on unsupported browsers.
|
|
if (typeof ShadowRoot !== 'undefined' && ShadowRoot && rootNode instanceof ShadowRoot) {
|
|
return rootNode;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* Gets the currently-focused element on the page while
|
|
* also piercing through Shadow DOM boundaries.
|
|
*/
|
|
function _getFocusedElementPierceShadowDom() {
|
|
let activeElement = typeof document !== 'undefined' && document ?
|
|
document.activeElement : null;
|
|
while (activeElement && activeElement.shadowRoot) {
|
|
const newActiveElement = activeElement.shadowRoot.activeElement;
|
|
if (newActiveElement === activeElement) {
|
|
break;
|
|
}
|
|
else {
|
|
activeElement = newActiveElement;
|
|
}
|
|
}
|
|
return activeElement;
|
|
}
|
|
/** Gets the target of an event while accounting for Shadow DOM. */
|
|
function _getEventTarget(event) {
|
|
// If an event is bound outside the Shadow DOM, the `event.target` will
|
|
// point to the shadow root so we have to use `composedPath` instead.
|
|
return (event.composedPath ? event.composedPath()[0] : event.target);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/** Gets whether the code is currently running in a test environment. */
|
|
function _isTestEnvironment() {
|
|
// We can't use `declare const` because it causes conflicts inside Google with the real typings
|
|
// for these symbols and we can't read them off the global object, because they don't appear to
|
|
// be attached there for some runners like Jest.
|
|
// (see: https://github.com/angular/components/issues/23365#issuecomment-938146643)
|
|
return (
|
|
// @ts-ignore
|
|
(typeof __karma__ !== 'undefined' && !!__karma__) ||
|
|
// @ts-ignore
|
|
(typeof jasmine !== 'undefined' && !!jasmine) ||
|
|
// @ts-ignore
|
|
(typeof jest !== 'undefined' && !!jest) ||
|
|
// @ts-ignore
|
|
(typeof Mocha !== 'undefined' && !!Mocha));
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
/**
|
|
* Generated bundle index. Do not edit.
|
|
*/
|
|
|
|
export { Platform, PlatformModule, _getEventTarget, _getFocusedElementPierceShadowDom, _getShadowRoot, _isTestEnvironment, _supportsShadowDom, getRtlScrollAxisType, getSupportedInputTypes, normalizePassiveListenerOptions, supportsPassiveEventListeners, supportsScrollBehavior };
|
|
|
|
//# sourceMappingURL=platform.js.map
|