native-fn 1.0.38 → 1.0.40

package/dist/plugin/fullscreen/index.mjs

@@ -0,0 +1,521 @@
+var USER_AGENT = navigator.userAgent;
+
+var OS;
+(function (OS) {
+    OS["Unknown"] = "Unknown";
+    OS["Android"] = "Android";
+    OS["iOS"] = "iOS";
+    OS["Windows"] = "Windows";
+    OS["MacOS"] = "MacOS";
+})(OS || (OS = {}));
+var Devices;
+(function (Devices) {
+    Devices["Unknown"] = "Unknown";
+    Devices["Mobile"] = "Mobile";
+    Devices["Desktop"] = "Desktop";
+})(Devices || (Devices = {}));
+var Engines;
+(function (Engines) {
+    Engines["Unknown"] = "Unknown";
+    Engines["EdgeHTML"] = "EdgeHTML";
+    Engines["ArkWeb"] = "ArkWeb";
+    Engines["Blink"] = "Blink";
+    Engines["Presto"] = "Presto";
+    Engines["WebKit"] = "WebKit";
+    Engines["Trident"] = "Trident";
+    Engines["NetFront"] = "NetFront";
+    Engines["KHTML"] = "KHTML";
+    Engines["Tasman"] = "Tasman";
+    Engines["Gecko"] = "Gecko";
+})(Engines || (Engines = {}));
+var Browsers;
+(function (Browsers) {
+    Browsers["Unknown"] = "Unknown";
+    Browsers["Chrome"] = "Chrome";
+    Browsers["Safari"] = "Safari";
+    Browsers["Edge"] = "Edge";
+    Browsers["Firefox"] = "Firefox";
+    Browsers["Opera"] = "Opera";
+    Browsers["IE"] = "IE";
+    Browsers["SamsungInternet"] = "SamsungInternet";
+})(Browsers || (Browsers = {}));
+var DEVICE_NAME = Devices.Unknown;
+var OS_NAME = OS.Unknown;
+Engines.Unknown;
+Browsers.Unknown;
+function resolveWindowsVersion(string) {
+    if (string === undefined)
+        return '';
+    var mapped = {
+        '4.90': 'ME',
+        'NT3.51': 'NT 3.11',
+        'NT4.0': 'NT 4.0',
+        'NT 5.0': '2000',
+        'NT 5.1': 'XP',
+        'NT 5.2': 'XP',
+        'NT 6.0': 'Vista',
+        'NT 6.1': '7',
+        'NT 6.2': '8',
+        'NT 6.3': '8.1',
+        'NT 6.4': '10',
+        'NT 10.0': '10',
+        'ARM': 'RT'
+    }[string];
+    if (mapped !== undefined)
+        return mapped;
+    return string;
+}
+function resolveUnderscoreVersion(string) {
+    if (string === undefined)
+        return '';
+    return string.replace(/_/g, '.');
+}
+function resolveVersion(string, resolver) {
+    if (typeof resolver === 'function')
+        return resolver(string);
+    if (typeof resolver === 'string')
+        return resolver;
+    if (string === undefined)
+        return '';
+    return string;
+}
+var OS_RESOLVER_MAP = [
+    [/windows nt (6\.[23]); arm/i, OS.Windows, resolveWindowsVersion],
+    [/windows (?:phone|mobile|iot)(?: os)?[\/ ]?([\d.]*( se)?)/i, OS.Windows, resolveWindowsVersion],
+    [/windows[\/ ](1[01]|2000|3\.1|7|8(\.1)?|9[58]|me|server 20\d\d( r2)?|vista|xp)/i, OS.Windows, resolveWindowsVersion],
+    [/windows nt ?([\d.)]*)(?!.+xbox)/i, OS.Windows, resolveWindowsVersion],
+    [/\bwin(?=3| ?9|n)(?:nt| 9x )?([\d.;]*)/i, OS.Windows, resolveWindowsVersion],
+    [/windows ce\/?([\d.]*)/i, OS.Windows, resolveWindowsVersion],
+    [/[adehimnop]{4,7}\b(?:.*os (\w+) like mac|; opera)/i, OS.iOS, resolveUnderscoreVersion],
+    [/(?:ios;fbsv|ios(?=.+ip(?:ad|hone))|ip(?:ad|hone)(?: |.+i(?:pad)?)os)[\/ ]([\w.]+)/i, OS.iOS, resolveUnderscoreVersion],
+    [/cfnetwork\/.+darwin/i, OS.iOS, resolveUnderscoreVersion],
+    [/mac os x ?([\w. ]*)/i, OS.MacOS, resolveUnderscoreVersion],
+    [/(?:macintosh|mac_powerpc\b)(?!.+(haiku|morphos))/i, OS.MacOS, resolveUnderscoreVersion],
+    [/droid ([\w.]+)\b.+(android[- ]x86)/i, OS.Android],
+    [/android\w*[-\/.; ]?([\d.]*)/i, OS.Android],
+];
+var ENGINE_RESOLVER_MAP = [
+    [/windows.+ edge\/([\w.]+)/i, Engines.EdgeHTML],
+    [/arkweb\/([\w.]+)/i, Engines.ArkWeb],
+    [/webkit\/537\.36.+chrome\/(?!27)([\w.]+)/i, Engines.Blink],
+    [/presto\/([\w.]+)/i, Engines.Presto],
+    [/webkit\/([\w.]+)/i, Engines.WebKit],
+    [/trident\/([\w.]+)/i, Engines.Trident],
+    [/netfront\/([\w.]+)/i, Engines.NetFront],
+    [/khtml[\/ ]\(?([\w.]+)/i, Engines.KHTML],
+    [/tasman[\/ ]\(?([\w.]+)/i, Engines.Tasman],
+    [/rv:([\w.]{1,9})\b.+gecko/i, Engines.Gecko]
+];
+var BROWSER_RESOLVER_MAP = [
+    [/\b(?:crmo|crios)\/([\w.]+)/i, Browsers.Chrome],
+    [/webview.+edge\/([\w.]+)/i, Browsers.Edge],
+    [/edg(?:e|ios|a)?\/([\w.]+)/i, Browsers.Edge],
+    [/opera mini\/([-\w.]+)/i, Browsers.Opera],
+    [/opera [mobileta]{3,6}\b.+version\/([-\w.]+)/i, Browsers.Opera],
+    [/opera(?:.+version\/|[\/ ]+)([\w.]+)/i, Browsers.Opera],
+    [/opios[\/ ]+([\w.]+)/i, Browsers.Opera],
+    [/\bop(?:rg)?x\/([\w.]+)/i, Browsers.Opera],
+    [/\bopr\/([\w.]+)/i, Browsers.Opera],
+    [/iemobile(?:browser|boat|jet)[\/ ]?([\d.]*)/i, Browsers.IE],
+    [/(?:ms|\()ie ([\w.]+)/i, Browsers.IE],
+    [/trident.+rv[: ]([\w.]{1,9})\b.+like gecko/i, Browsers.IE],
+    [/\bfocus\/([\w.]+)/i, Browsers.Firefox],
+    [/\bopt\/([\w.]+)/i, Browsers.Opera],
+    [/coast\/([\w.]+)/i, Browsers.Opera],
+    [/fxios\/([\w.-]+)/i, Browsers.Firefox],
+    [/samsungbrowser\/([\w.]+)/i, Browsers.SamsungInternet],
+    [/headlesschrome(?:\/([\w.]+)| )/i, Browsers.Chrome],
+    [/wv\).+chrome\/([\w.]+).+edgw\//i, Browsers.Edge],
+    [/ wv\).+(chrome)\/([\w.]+)/i, Browsers.Chrome],
+    [/chrome\/([\w.]+) mobile/i, Browsers.Chrome],
+    [/chrome\/v?([\w.]+)/i, Browsers.Chrome],
+    [/version\/([\w.,]+) .*mobile(?:\/\w+ | ?)safari/i, Browsers.Safari],
+    [/iphone .*mobile(?:\/\w+ | ?)safari/i, Browsers.Safari],
+    [/version\/([\w.,]+) .*safari/i, Browsers.Safari],
+    [/webkit.+?(?:mobile ?safari|safari)(\/[\w.]+)/i, Browsers.Safari, '1'],
+    [/(?:mobile|tablet);.*firefox\/([\w.-]+)/i, Browsers.Firefox],
+    [/mobile vr; rv:([\w.]+)\).+firefox/i, Browsers.Firefox],
+    [/firefox\/([\w.]+)/i, Browsers.Firefox],
+];
+for (var i = 0; i < OS_RESOLVER_MAP.length; i++) {
+    var map = OS_RESOLVER_MAP[i];
+    var regexp = map[0];
+    var os = map[1];
+    var resolver = map[2];
+    var matched = USER_AGENT.match(regexp);
+    if (matched !== null) {
+        OS_NAME = os;
+        resolveVersion(matched[1], resolver);
+        if (os === OS.iOS || os === OS.Android)
+            DEVICE_NAME = Devices.Mobile;
+        else if (os === OS.Windows || os === OS.MacOS)
+            DEVICE_NAME = Devices.Desktop;
+        break;
+    }
+}
+for (var i = 0; i < ENGINE_RESOLVER_MAP.length; i++) {
+    var map = ENGINE_RESOLVER_MAP[i];
+    var regexp = map[0];
+    map[1];
+    var resolver = map[2];
+    var matched = USER_AGENT.match(regexp);
+    if (matched !== null) {
+        resolveVersion(matched[1], resolver);
+        break;
+    }
+}
+for (var i = 0; i < BROWSER_RESOLVER_MAP.length; i++) {
+    var map = BROWSER_RESOLVER_MAP[i];
+    var regexp = map[0];
+    map[1];
+    var resolver = map[2];
+    var matched = USER_AGENT.match(regexp);
+    if (matched !== null) {
+        resolveVersion(matched[1], resolver);
+        break;
+    }
+}
+((function () {
+    if (typeof globalThis.document === 'undefined')
+        return '';
+    var canvas = globalThis.document.createElement('canvas');
+    if (typeof canvas.getContext !== 'function')
+        return '';
+    var context = canvas.getContext('webgl2') || canvas.getContext('experimental-webgl') || canvas.getContext('webgl');
+    if (context === null)
+        return '';
+    if (context instanceof WebGLRenderingContext || 'getParameter' in context && typeof context.getParameter === 'function') {
+        var extension = context.getExtension('WEBGL_debug_renderer_info');
+        if (extension === null)
+            return context.getParameter(context.RENDERER);
+        else
+            return context.getParameter(extension.UNMASKED_RENDERER_WEBGL);
+    }
+    else {
+        return '';
+    }
+}))();
+DEVICE_NAME === Devices.Mobile;
+DEVICE_NAME === Devices.Desktop;
+((function () {
+    if (OS_NAME === OS.iOS)
+        return 'standalone' in navigator && !!navigator.standalone;
+    else
+        return globalThis.matchMedia('(display-mode: standalone)').matches;
+}))();
+
+var API_VARIANTS = {
+    standard: {
+        enabled: 'fullscreenEnabled',
+        element: 'fullscreenElement',
+        request: 'requestFullscreen',
+        exit: 'exitFullscreen',
+        events: { change: 'fullscreenchange', error: 'fullscreenerror' },
+    },
+    webkit: {
+        enabled: 'webkitFullscreenEnabled',
+        element: 'webkitFullscreenElement',
+        request: 'webkitRequestFullscreen',
+        exit: 'webkitExitFullscreen',
+        events: { change: 'webkitfullscreenchange', error: 'webkitfullscreenerror' },
+    },
+    moz: {
+        enabled: 'mozFullScreenEnabled',
+        element: 'mozFullScreenElement',
+        request: 'mozRequestFullScreen',
+        exit: 'mozCancelFullScreen',
+        events: { change: 'mozfullscreenchange', error: 'mozfullscreenerror' },
+    },
+    ms: {
+        enabled: 'msFullscreenEnabled',
+        element: 'msFullscreenElement',
+        request: 'msRequestFullscreen',
+        exit: 'msExitFullscreen',
+        events: { change: 'MSFullscreenChange', error: 'MSFullscreenError' },
+    },
+};
+function detectApi() {
+    var element = globalThis.document.documentElement;
+    if ('fullscreenEnabled' in globalThis.document || 'exitFullscreen' in globalThis.document) {
+        return API_VARIANTS.standard;
+    }
+    var keys = ['webkit', 'moz', 'ms'];
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        var api = API_VARIANTS[key];
+        if (api.enabled in globalThis.document || api.element in globalThis.document || api.exit in globalThis.document) {
+            if (key === 'webkit' && 'webkitRequestFullScreen' in element)
+                api.request = 'webkitRequestFullScreen';
+            return api;
+        }
+    }
+    if ('webkitCurrentFullScreenElement' in globalThis.document) {
+        var api = {
+            enabled: 'webkitFullscreenEnabled',
+            element: 'webkitCurrentFullScreenElement',
+            request: 'webkitRequestFullscreen',
+            exit: 'webkitExitFullscreen',
+            events: API_VARIANTS.webkit.events,
+        };
+        if ('webkitRequestFullScreen' in element)
+            api.request = 'webkitRequestFullScreen';
+        return api;
+    }
+    return null;
+}
+function isIOS() {
+    return OS.iOS === OS_NAME;
+}
+function createFullscreenUtils() {
+    var api = detectApi();
+    var lastIOSVideo = null;
+    var eventsBridged = false;
+    function bridgeEvents() {
+        if (eventsBridged)
+            return;
+        eventsBridged = true;
+        var dispatching = false;
+        function emit(type) {
+            if (dispatching)
+                return;
+            dispatching = true;
+            globalThis.document.dispatchEvent(new Event(type, { bubbles: true, cancelable: false }));
+            Promise.resolve().then(function () {
+                dispatching = false;
+            });
+        }
+        function emitChange() {
+            emit('fullscreenchange');
+        }
+        function emitError() {
+            emit('fullscreenerror');
+        }
+        var changeEvents = ['webkitfullscreenchange', 'mozfullscreenchange', 'MSFullscreenChange'];
+        var errorEvents = ['webkitfullscreenerror', 'mozfullscreenerror', 'MSFullscreenError'];
+        changeEvents.forEach(function (eventType) {
+            globalThis.document.addEventListener(eventType, emitChange, false);
+        });
+        errorEvents.forEach(function (eventType) {
+            globalThis.document.addEventListener(eventType, emitError, false);
+        });
+        if (isIOS()) {
+            bridgeIOSVideoEvents();
+            var observer = new MutationObserver(function () {
+                bridgeIOSVideoEvents();
+            });
+            observer.observe(globalThis.document.documentElement, { childList: true, subtree: true });
+        }
+    }
+    function bridgeIOSVideoEvents() {
+        var videos = document.querySelectorAll('video');
+        videos.forEach(function (video) {
+            if (video.__fsBridged__ || !('webkitEnterFullscreen' in video || 'onwebkitbeginfullscreen' in video))
+                return;
+            function emitChange() {
+                document.dispatchEvent(new Event('fullscreenchange'));
+            }
+            video.addEventListener('webkitbeginfullscreen', emitChange, false);
+            video.addEventListener('webkitendfullscreen', emitChange, false);
+            video.__fsBridged__ = true;
+        });
+    }
+    function getEnabled() {
+        if (api === null) {
+            if (!isIOS())
+                return false;
+            var videos = document.querySelectorAll('video');
+            for (var i = 0; i < videos.length; i++) {
+                var video = videos[i];
+                if (video.webkitSupportsFullscreen || 'webkitEnterFullscreen' in video)
+                    return true;
+            }
+            return false;
+        }
+        var enabledValue = document[api.enabled];
+        if (typeof enabledValue === 'boolean')
+            return enabledValue;
+        return typeof document[api.element] !== 'undefined';
+    }
+    function getElement() {
+        if (api === null) {
+            if (lastIOSVideo && lastIOSVideo.webkitDisplayingFullscreen)
+                return lastIOSVideo;
+            return null;
+        }
+        var currentElement = document[api.element];
+        if (currentElement !== null && currentElement !== undefined)
+            return currentElement;
+        return null;
+    }
+    function getIsFullscreen() {
+        return getElement() !== null;
+    }
+    function request(target, options) {
+        return new Promise(function (resolve, reject) {
+            if (api !== null) {
+                var method = target[api.request];
+                if (typeof method === 'function') {
+                    try {
+                        var result = method.call(target, options);
+                        if (result !== undefined && typeof result.then === 'function') {
+                            result
+                                .then(function () {
+                                resolve();
+                            })
+                                .catch(function () {
+                                if (!isIOS()) {
+                                    reject();
+                                    return;
+                                }
+                                fallbackToIOSVideo();
+                            });
+                            return;
+                        }
+                        else {
+                            resolve();
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        if (!isIOS()) {
+                            reject();
+                            return;
+                        }
+                    }
+                }
+            }
+            function fallbackToIOSVideo() {
+                if (isIOS() && target.tagName.toUpperCase() === 'VIDEO') {
+                    var video = target;
+                    if (video.webkitSupportsFullscreen && typeof video.webkitEnterFullscreen === 'function') {
+                        lastIOSVideo = video;
+                        bridgeIOSVideoEvents();
+                        video.webkitEnterFullscreen();
+                        resolve();
+                        return;
+                    }
+                }
+                reject();
+            }
+            fallbackToIOSVideo();
+        });
+    }
+    function exit() {
+        return new Promise(function (resolve, reject) {
+            if (api !== null) {
+                var method = document[api.exit];
+                if (typeof method === 'function') {
+                    var result = method.call(document);
+                    if (result !== undefined && typeof result.then === 'function') {
+                        result
+                            .then(function () {
+                            resolve();
+                        })
+                            .catch(function () {
+                            reject();
+                        });
+                        return;
+                    }
+                    else {
+                        resolve();
+                        return;
+                    }
+                }
+            }
+            if (isIOS() && lastIOSVideo !== null) {
+                if (typeof lastIOSVideo.webkitExitFullscreen === 'function' && lastIOSVideo.webkitDisplayingFullscreen === true) {
+                    lastIOSVideo.webkitExitFullscreen();
+                    lastIOSVideo = null;
+                    resolve();
+                    return;
+                }
+                var videos = document.querySelectorAll('video');
+                for (var i = 0; i < videos.length; i++) {
+                    var video = videos[i];
+                    if (typeof video.webkitExitFullscreen === 'function' && video.webkitDisplayingFullscreen === true) {
+                        video.webkitExitFullscreen();
+                        resolve();
+                        return;
+                    }
+                }
+            }
+            if (!getElement()) {
+                resolve();
+                return;
+            }
+            reject();
+        });
+    }
+    function toggle(target, options) {
+        if (getIsFullscreen())
+            return exit();
+        else
+            return request(target, options);
+    }
+    function onChange(handler) {
+        var listeners = [];
+        function listen(eventType) {
+            function wrapper(event) {
+                handler(event);
+            }
+            document.addEventListener(eventType, wrapper, false);
+            listeners.push(function () {
+                document.removeEventListener(eventType, wrapper, false);
+            });
+        }
+        listen('fullscreenchange');
+        return function () {
+            listeners.forEach(function (cleanup) {
+                cleanup();
+            });
+        };
+    }
+    function onError(handler) {
+        var listeners = [];
+        function listen(eventType) {
+            function wrapper(event) {
+                handler(event);
+            }
+            document.addEventListener(eventType, wrapper, false);
+            listeners.push(function () {
+                document.removeEventListener(eventType, wrapper, false);
+            });
+        }
+        listen('fullscreenerror');
+        return function () {
+            listeners.forEach(function (cleanup) {
+                cleanup();
+            });
+        };
+    }
+    bridgeEvents();
+    return {
+        get enabled() {
+            return getEnabled();
+        },
+        get element() {
+            return getElement();
+        },
+        get isFullscreen() {
+            return getIsFullscreen();
+        },
+        request: request,
+        exit: exit,
+        toggle: toggle,
+        onChange: onChange,
+        onError: onError,
+    };
+}
+var FullscreenUtils = createFullscreenUtils();
+
+var Fullscreen = FullscreenUtils;
+
+var NativeFullscreenPlugin = {
+    installed: false,
+    name: 'Fullscreen',
+    module: Fullscreen,
+    Constants: {},
+    Errors: {}
+};
+
+export { NativeFullscreenPlugin as default };