native-fn 1.0.81 → 1.0.82

package/dist/plugin/dimension/src/plugin/appearance/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./appearance";
+import type { AppearanceInstance } from "./appearance";
+import { Appearances } from "../constants";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Appearance: AppearanceInstance;
+    }
+    interface NativeConstants {
+        Appearances: typeof Appearances;
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/clipboard/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { ClipboardInstance } from "../types";
+declare const Clipboard: ClipboardInstance;
+export default Clipboard;

package/dist/plugin/dimension/src/plugin/clipboard/index.d.ts

@@ -0,0 +1,5 @@
+import type { NativePlugin } from "../../types";
+import type { ClipboardInstance } from "./types";
+export * from "./types";
+declare const NativeClipboardPlugin: NativePlugin<'Clipboard', ClipboardInstance, {}, {}>;
+export default NativeClipboardPlugin;

package/dist/plugin/dimension/src/plugin/clipboard/types/appearance.d.ts

@@ -0,0 +1,13 @@
+import { Appearances } from "../constants";
+import { NativeModule } from "../../../types";
+export declare interface ListenerEntry {
+    fn: (appearance: Appearances) => any;
+    capture: boolean;
+    once: boolean;
+    signal?: AbortSignal;
+}
+export declare interface AppearanceInstance extends NativeModule {
+    get value(): Appearances;
+    set value(appearances: Exclude<Appearances, Appearances.Unknown>);
+    onchange(listener: (appearance?: Appearances) => any, options?: boolean | AddEventListenerOptions): () => void;
+}

package/dist/plugin/dimension/src/plugin/clipboard/types/clipboard.d.ts

@@ -0,0 +1,4 @@
+export declare interface ClipboardInstance {
+    copy(item: any): Promise<boolean>;
+    paste(): Promise<string>;
+}

package/dist/plugin/dimension/src/plugin/clipboard/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./clipboard";
+import type { ClipboardInstance } from "./clipboard";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Clipboard: ClipboardInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/dimension/cores/index.d.ts

@@ -0,0 +1,3 @@
+import { DimensionInstance } from "../types";
+declare const Dimension: DimensionInstance;
+export default Dimension;

package/dist/plugin/dimension/src/plugin/dimension/index.d.ts

@@ -0,0 +1,4 @@
+import { NativePlugin } from "../../types";
+import { DimensionInstance } from "./types";
+declare const NativeDimensionPlugin: NativePlugin<'Dimension', DimensionInstance, {}, {}>;
+export default NativeDimensionPlugin;

package/dist/plugin/dimension/src/plugin/dimension/types/dimension.d.ts

@@ -0,0 +1,8 @@
+export declare interface ListenerEntry {
+    fn: () => any;
+    capture: boolean;
+    once: boolean;
+    signal?: AbortSignal;
+}
+export declare interface DimensionInstance {
+}

package/dist/plugin/dimension/src/plugin/dimension/types/index.d.ts

@@ -0,0 +1,13 @@
+import { DimensionInstance } from "./dimension";
+import Dimension from "../cores";
+export * from "./dimension";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Dimension: DimensionInstance;
+    }
+    interface NativeConstants {
+        Dimension: typeof Dimension;
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/fullscreen/cores/index.d.ts

@@ -0,0 +1,35 @@
+import { FullscreenInstance } from "../types";
+declare const Fullscreen: FullscreenInstance;
+declare global {
+    interface HTMLVideoElement {
+        webkitEnterFullscreen?: () => void;
+        webkitExitFullscreen?: () => void;
+        webkitSupportsFullscreen?: boolean;
+        webkitDisplayingFullscreen?: boolean;
+        __fsBridged__?: boolean;
+    }
+    interface Document {
+        readonly fullscreenEnabled: boolean;
+        fullscreenElement?: Element | null;
+        exitFullscreen: () => Promise<void>;
+        readonly webkitFullscreenEnabled?: boolean;
+        webkitFullscreenElement?: Element | null;
+        webkitCurrentFullScreenElement?: Element | null;
+        webkitExitFullscreen?: () => Promise<void>;
+        webkitCancelFullScreen?: () => Promise<void>;
+        readonly mozFullScreenEnabled?: boolean;
+        mozFullScreenElement?: Element | null;
+        mozCancelFullScreen?: () => Promise<void>;
+        readonly msFullscreenEnabled?: boolean;
+        msFullscreenElement?: Element | null;
+        msExitFullscreen?: () => Promise<void>;
+    }
+    interface Element {
+        requestFullscreen: (options?: FullscreenOptions) => Promise<void>;
+        webkitRequestFullscreen?: (options?: FullscreenOptions) => Promise<void>;
+        webkitRequestFullScreen?: (options?: FullscreenOptions) => Promise<void>;
+        mozRequestFullScreen?: () => Promise<void>;
+        msRequestFullscreen?: () => Promise<void>;
+    }
+}
+export default Fullscreen;

package/dist/plugin/dimension/src/plugin/fullscreen/index.d.ts

@@ -0,0 +1,5 @@
+import type { NativePlugin } from "../../types";
+import type { FullscreenInstance } from "./types";
+export * from "./types";
+declare const NativeFullscreenPlugin: NativePlugin<'Fullscreen', FullscreenInstance, {}, {}>;
+export default NativeFullscreenPlugin;

package/dist/plugin/dimension/src/plugin/fullscreen/types/fullscreen.d.ts

@@ -0,0 +1,10 @@
+export declare interface FullscreenInstance {
+    enabled: boolean;
+    element: any;
+    isFullscreen: boolean;
+    request(target?: any, options?: FullscreenOptions): Promise<void>;
+    exit(): Promise<void>;
+    toggle(target?: any, options?: FullscreenOptions): Promise<void>;
+    onchange(handler: (event: Event) => void): () => void;
+    onerror(handler: (event: Event) => void): () => void;
+}

package/dist/plugin/dimension/src/plugin/fullscreen/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./fullscreen";
+import type { FullscreenInstance } from "./fullscreen";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Fullscreen: FullscreenInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/platform/constants/index.d.ts

@@ -0,0 +1,42 @@
+export declare enum OS {
+    Unknown = "Unknown",
+    Android = "Android",
+    iOS = "iOS",
+    Windows = "Windows",
+    MacOS = "MacOS"
+}
+export declare enum Devices {
+    Unknown = "Unknown",
+    Mobile = "Mobile",
+    Desktop = "Desktop"
+}
+export declare enum Engines {
+    Unknown = "Unknown",
+    EdgeHTML = "EdgeHTML",
+    ArkWeb = "ArkWeb",
+    Blink = "Blink",
+    Presto = "Presto",
+    WebKit = "WebKit",
+    Trident = "Trident",
+    NetFront = "NetFront",
+    KHTML = "KHTML",
+    Tasman = "Tasman",
+    Gecko = "Gecko"
+}
+export declare enum Browsers {
+    Unknown = "Unknown",
+    Chrome = "Chrome",
+    Safari = "Safari",
+    Edge = "Edge",
+    Firefox = "Firefox",
+    Opera = "Opera",
+    IE = "IE",
+    SamsungInternet = "SamsungInternet"
+}
+export declare enum CrossPlatformFramework {
+    Unknown = "Unknown",
+    ReactNative = "ReactNative",
+    Electron = "Electron",
+    Cordova = "Cordova"
+}
+export declare const USER_AGENT: string;

package/dist/plugin/dimension/src/plugin/platform/cores/index.d.ts

@@ -0,0 +1,45 @@
+import { PlatformInstance } from "../types";
+declare global {
+    var cordova: string | undefined;
+    var device: CordovaDevice | undefined;
+    interface Navigator {
+        userAgent?: string;
+        userAgentData?: UserAgentData;
+        language?: string;
+        languages?: readonly string[];
+        browserLanguage?: string;
+        systemLanguage?: string;
+        userLanguage?: string;
+        connection?: NavigatorConnection;
+        mozConnection?: NavigatorConnection;
+        webkitConnection?: NavigatorConnection;
+    }
+}
+interface NavigatorConnection {
+    effectiveType?: 'slow-2g' | '2g' | '3g' | '4g';
+    type?: 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other';
+    downlink?: number;
+    rtt?: number;
+    saveData?: boolean;
+}
+interface CordovaDevice {
+    platform: string;
+    version: string;
+}
+interface ModernUserAgentDataBrand {
+    brand: string;
+    version: string;
+}
+type UserAgentDataBrand = ModernUserAgentDataBrand | string | null | undefined;
+interface UserAgentDataValues {
+    brands?: UserAgentDataBrand[];
+    fullVersionList?: UserAgentDataBrand[];
+    platformVersion?: string | null | undefined;
+    platform?: string | null | undefined;
+    mobile?: boolean;
+}
+interface UserAgentData {
+    getHighEntropyValues?(hints: string[]): Promise<UserAgentDataValues>;
+}
+declare const Platform: PlatformInstance;
+export default Platform;

package/dist/plugin/dimension/src/plugin/platform/index.d.ts

@@ -0,0 +1,12 @@
+import type { NativePlugin } from "../../types";
+import { PlatformInstance } from "./types";
+import { Browsers, CrossPlatformFramework, Devices, Engines, OS } from "./constants";
+export * from "./types";
+declare const NativePlatformPlugin: NativePlugin<'Platform', PlatformInstance, {
+    OS: typeof OS;
+    Devices: typeof Devices;
+    Engines: typeof Engines;
+    Browsers: typeof Browsers;
+    CrossPlatformFramework: typeof CrossPlatformFramework;
+}, {}>;
+export default NativePlatformPlugin;

package/dist/plugin/dimension/src/plugin/platform/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./platform";
+import type { PlatformInstance } from "./platform";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Platform: PlatformInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/platform/types/platform.d.ts

@@ -0,0 +1,43 @@
+import { Browsers, CrossPlatformFramework, Devices, Engines, OS } from "../constants";
+export declare interface PlatformInstance {
+    os: NameVersionPair<OS>;
+    engine: NameVersionPair<Engines>;
+    browser: NameVersionPair<Browsers>;
+    device: Devices;
+    crossPlatformFramework: CrossPlatformFramework;
+    network: Network;
+    locale: Locale;
+    dimension: Dimension;
+    renderer: string;
+    userAgent: string;
+    readyState: 'loading' | 'complete';
+    isNode: boolean;
+    isStandalone: boolean;
+    isWebview: boolean;
+    onready(callback: (platform: PlatformInstance) => void): void;
+}
+export declare interface NameVersionPair<T> {
+    name: T;
+    version: string;
+}
+export declare interface Network {
+    isOnline: boolean | null;
+    effectiveType: 'slow-2g' | '2g' | '3g' | '4g' | null;
+    type: 'bluetooth' | 'cellular' | 'ethernet' | 'none' | 'wifi' | 'wimax' | 'other' | null;
+    downlink: number | null;
+    rtt: number | null;
+    saveData: boolean | null;
+}
+export declare interface Dimension {
+    outerWidth: number;
+    outerHeight: number;
+    innerWidth: number;
+    innerHeight: number;
+    scale: number;
+}
+export declare interface Locale {
+    language: string;
+    languages: string[];
+    timezone: string;
+    timezoneOffset: number;
+}

package/dist/plugin/dimension/src/plugin/theme/constants/index.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_IE_MOBILE: boolean;
+export declare const IS_WINDOWS_PHONE: boolean;

package/dist/plugin/dimension/src/plugin/theme/cores/index.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeInstance } from "../types";
+declare const Theme: ThemeInstance;
+export default Theme;

package/dist/plugin/dimension/src/plugin/theme/index.d.ts

@@ -0,0 +1,5 @@
+import type { NativePlugin } from "../../types";
+import type { ThemeInstance } from "./types";
+export * from "./types";
+declare const NativeThemePlugin: NativePlugin<'Theme', ThemeInstance, {}, {}>;
+export default NativeThemePlugin;

package/dist/plugin/dimension/src/plugin/theme/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./theme";
+import type { ThemeInstance } from "./theme";
+declare module 'native-fn' {
+    interface NativePlugins {
+        Theme: ThemeInstance;
+    }
+    interface NativeConstants {
+    }
+    interface NativeErrors {
+    }
+}

package/dist/plugin/dimension/src/plugin/theme/types/theme.d.ts

@@ -0,0 +1,4 @@
+export declare interface ThemeInstance {
+    get value(): string | undefined;
+    set value(color: string | undefined);
+}

package/dist/plugin/dimension/src/types/event-listener-util.d.ts

@@ -0,0 +1,11 @@
+export declare interface EventListenerUtil {
+    useStd: boolean;
+    add<T extends EventTarget | undefined, E extends Event = Event>(target: T, eventListenerOptions: EventListenerOptions<NonNullable<T>, E>): void;
+    remove<T extends EventTarget | undefined, E extends Event = Event>(target: T, eventListenerOptions: EventListenerOptions<NonNullable<T>, E>): void;
+    withVender(target: any, type?: string): string;
+}
+export declare interface EventListenerOptions<T extends EventTarget = EventTarget, E extends Event = Event> {
+    type?: string | undefined;
+    callback: ((this: T, event: E) => void) | EventListenerObject | null;
+    options?: AddEventListenerOptions | boolean;
+}

package/dist/plugin/dimension/src/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./native";

package/dist/plugin/dimension/src/types/native.d.ts

@@ -0,0 +1,27 @@
+import { PluginNotExtendedError } from "../errors/plugin-not-extended-error";
+export declare interface NativePlugins {
+}
+export declare interface NativeConstants extends Record<string, any> {
+}
+export declare interface NativeErrors extends Record<string, ErrorConstructor> {
+    PluginNotExtendedError: typeof PluginNotExtendedError;
+}
+export declare interface NativePlugin<Key extends string, Module, Constants extends Record<string, any> = Record<string, any>, Errors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>> {
+    installed: boolean;
+    name: Key;
+    module: Module;
+    Constants: Constants;
+    Errors: Errors;
+}
+export declare type ExtendedNativeBase<Key extends string, Module, Constants extends Record<string, any> = Record<string, any>, Errors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>> = NativeBase<NativePlugins & {
+    [Plugin in Key]: Module;
+}, NativeConstants & Constants, NativeErrors & Errors>;
+export declare type NativeBase<Plugins, AssignedConstants extends Record<string, any> = Record<string, any>, AssignedErrors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>> = {
+    Version: string;
+    Constants: AssignedConstants;
+    Errors: AssignedErrors;
+    extends: <Key extends string, Module, Constants extends Record<string, any> = Record<string, any>, Errors extends Record<string, ErrorConstructor> = Record<string, ErrorConstructor>>(this: NativeBase<Plugins, AssignedConstants, AssignedErrors>, plugin: NativePlugin<Key, Module, Constants, Errors>) => NativeBase<Plugins & {
+        [Plugin in Key]: Module;
+    }, AssignedConstants & Constants, AssignedErrors & Errors>;
+} & NativePlugins;
+export type NativeInstance = NativeBase<NativePlugins, NativeConstants, NativeErrors>;

package/dist/plugin/dimension/src/utils/assign.d.ts

@@ -0,0 +1 @@
+export default function assign(...args: any[]): any;

package/dist/plugin/dimension/src/utils/compare-version.d.ts

@@ -0,0 +1 @@
+export default function compareVersion(lhs: string, rhs: string): -1 | 0 | 1;

package/dist/plugin/dimension/src/utils/create-custom-error.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface ErrorConstructor {
+        captureStackTrace?: (targetObject: object, constructorOpt?: Function) => void;
+    }
+}
+export default function createCustomError(name: string, Base?: ErrorConstructor): ErrorConstructor;

package/dist/plugin/dimension/src/utils/create-hidden-element.d.ts

@@ -0,0 +1 @@
+export default function createHiddenElement<K extends keyof HTMLElementTagNameMap>(tagName: K, focusable?: boolean): HTMLElementTagNameMap[K] | undefined;

package/dist/plugin/dimension/src/utils/dispatch-click-event.d.ts

@@ -0,0 +1 @@
+export default function dispatchClickEvent(element: HTMLElement, view?: WindowProxy): void;

package/dist/plugin/dimension/src/utils/event-listener-utils.d.ts

@@ -0,0 +1,3 @@
+import type { EventListenerUtil } from "../types/event-listener-util";
+declare const EventListenerUtils: EventListenerUtil;
+export default EventListenerUtils;

package/dist/plugin/dimension/src/utils/get-topmost-window.d.ts

@@ -0,0 +1 @@
+export default function getTopmostWindow(): WindowProxy;

package/dist/plugin/dimension/src/utils/is-secure-context.d.ts

@@ -0,0 +1 @@
+export default function isSecureContext(): boolean;

package/dist/plugin/fullscreen/index.cjs

@@ -86,6 +86,9 @@ var Platform = {
     get network() {
         return getNetwork();
     },
+    get locale() {
+        return getLocale();
+    },
     get dimension() {
         return getDimension();
     },
@@ -99,12 +102,6 @@ var Platform = {
     get renderer() {
         return getRenderer();
     },
-    get isMobile() {
-        return this.device === Devices.Mobile;
-    },
-    get isDesktop() {
-        return this.device === Devices.Desktop;
-    },
     get isWebview() {
         return /; ?wv|applewebkit(?!.*safari)/i.test(this.userAgent);
     },
@@ -528,6 +525,127 @@ function getNetwork() {
     }
     return network;
 }
+function normalizeLocale(locale) {
+    if (locale === null || locale === undefined)
+        return locale;
+    if (locale.length === 0)
+        return null;
+    locale = locale.replace(/_/g, '-');
+    if (locale === 'C' || locale === 'posix' || locale === 'POSIX')
+        return 'en-US';
+    if (locale.indexOf('.') !== -1)
+        return normalizeLocale(locale.split('.')[0]);
+    if (locale.indexOf('@') !== -1)
+        return normalizeLocale(locale.split('@')[0]);
+    var parts = locale.split('-');
+    if (parts.length === 0)
+        return null;
+    parts[0] = parts[0].toLowerCase();
+    if (parts.length > 1 && parts[1].length === 2)
+        parts[1] = parts[1].toUpperCase();
+    if (parts.length > 2 && parts[1].length === 4)
+        parts[1] = parts[1].charAt(0).toUpperCase() + parts[1].slice(1).toLowerCase();
+    return parts.join('-');
+}
+function getLocale() {
+    var locale = {
+        language: '',
+        languages: [],
+        timezone: '',
+        timezoneOffset: 0,
+    };
+    function addLanguages(language) {
+        for (var i = 0; i < language.length; i++)
+            addLanguage(language[i]);
+    }
+    function addLanguage(language) {
+        language = normalizeLocale(language);
+        if (typeof language === "string" && locale.languages.indexOf(language) === -1) {
+            if (locale.language.length === 0)
+                locale.language = language;
+            locale.languages.push(language);
+        }
+    }
+    if (Platform.crossPlatformFramework === CrossPlatformFramework.ReactNative) {
+        try {
+            var reactNative = require('react-native');
+            var nativeModules = reactNative.NativeModules;
+            if (typeof nativeModules.SettingsManager !== 'undefined') {
+                var settingManager = nativeModules.SettingsManager;
+                if (typeof settingManager !== 'undefined') {
+                    var constant = typeof settingManager.getConstants === 'function'
+                        ? settingManager.getConstants()
+                        : settingManager;
+                    if (typeof constant !== 'undefined' && typeof constant.settings !== 'undefined') {
+                        var settings = constant.settings;
+                        if (typeof settings.AppleLocale === 'string')
+                            addLanguage(settings.AppleLocale);
+                        if (Array.isArray(settings.AppleLanguages) && settings.AppleLanguages.length > 0)
+                            addLanguages(settings.AppleLanguages);
+                    }
+                }
+            }
+            if (typeof nativeModules.I18nManager !== 'undefined') {
+                var i18nManager = nativeModules.I18nManager;
+                if (typeof i18nManager !== 'undefined') {
+                    var constant = typeof i18nManager.getConstants === 'function'
+                        ? i18nManager.getConstants()
+                        : i18nManager;
+                    if (typeof constant !== 'undefined' && typeof constant.localeIdentifier !== 'undefined')
+                        addLanguage(constant.localeIdentifier);
+                }
+            }
+        }
+        catch (_) {
+        }
+    }
+    if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron) {
+        try {
+            var electron = require('electron');
+            var app = electron.app;
+            if (typeof app.getLocale !== 'undefined')
+                addLanguage(app.getLocale());
+            if (typeof app.getSystemLocale !== 'undefined')
+                addLanguage(app.getSystemLocale());
+            if (typeof app.getPreferredSystemLanguages !== 'undefined')
+                addLanguages(app.getPreferredSystemLanguages());
+        }
+        catch (_) {
+        }
+    }
+    if (typeof Intl !== 'undefined') {
+        try {
+            addLanguage(Intl.DateTimeFormat().resolvedOptions().locale);
+        }
+        catch (_) {
+        }
+    }
+    if (typeof globalThis.navigator !== 'undefined') {
+        if (typeof globalThis.navigator.languages !== 'undefined')
+            addLanguages(globalThis.navigator.languages);
+        if (typeof globalThis.navigator.language !== 'undefined')
+            addLanguage(globalThis.navigator.language);
+        if (typeof globalThis.navigator.userLanguage !== 'undefined')
+            addLanguage(globalThis.navigator.userLanguage);
+        if (typeof globalThis.navigator.browserLanguage !== 'undefined')
+            addLanguage(globalThis.navigator.browserLanguage);
+        if (typeof globalThis.navigator.systemLanguage !== 'undefined')
+            addLanguage(globalThis.navigator.systemLanguage);
+    }
+    try {
+        if (typeof Intl !== 'undefined') {
+            locale.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }
+    }
+    catch (_) {
+    }
+    try {
+        locale.timezoneOffset = new Date().getTimezoneOffset();
+    }
+    catch (_) {
+    }
+    return locale;
+}
 function getDimension() {
     var dimension = {
         innerWidth: -1,
@@ -872,13 +990,11 @@ function detectApi() {
 function getDefaultTarget() {
     if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron) {
         var electron = require('electron');
-        var focusedWindow = electron.BrowserWindow.getFocusedWindow();
-        if (focusedWindow !== null)
-            return focusedWindow;
-        var allWindows = electron.BrowserWindow.getAllWindows();
-        if (allWindows.length === 0)
+        var browserWindow = electron.BrowserWindow;
+        var focusedWindow = browserWindow.getFocusedWindow() || browserWindow.getAllWindows()[0];
+        if (focusedWindow === undefined)
             throw new Error();
-        return allWindows[0];
+        return focusedWindow;
     }
     if (Platform.os.name === OS.iOS) {
         var video = globalThis.document.querySelector('video');
@@ -890,8 +1006,10 @@ function getDefaultTarget() {
 }
 function restoreElectronBrowserWindowOptions() {
     if (lastElectronBrowserWindowOptions !== null) {
-        lastElectronBrowserWindow.fullScreenable = lastElectronBrowserWindowOptions.fullScreenable;
-        lastElectronBrowserWindow.autoHideMenuBar = lastElectronBrowserWindowOptions.autoHideMenuBar;
+        if (lastElectronBrowserWindow !== null) {
+            lastElectronBrowserWindow.fullScreenable = lastElectronBrowserWindowOptions.fullScreenable;
+            lastElectronBrowserWindow.autoHideMenuBar = lastElectronBrowserWindowOptions.autoHideMenuBar;
+        }
         lastElectronBrowserWindowOptions = null;
     }
     lastElectronBrowserWindow = null;
@@ -920,7 +1038,8 @@ function bridgeEvents() {
     if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron) {
         try {
             var electron = require('electron');
-            var allWindows = electron.BrowserWindow.getAllWindows();
+            var browserWindow = electron.BrowserWindow;
+            var allWindows = browserWindow.getAllWindows();
             var _loop_1 = function (i) {
                 var currentWindow = allWindows[i];
                 currentWindow.on('enter-full-screen', function () {
@@ -935,8 +1054,8 @@ function bridgeEvents() {
             for (var i = 0; i < allWindows.length; i++) {
                 _loop_1(i);
             }
-            if (typeof electron.BrowserWindow.on === 'function') {
-                electron.BrowserWindow.on('browser-window-created', function (_, currentWindow) {
+            if (typeof browserWindow.on === 'function') {
+                browserWindow.on('browser-window-created', function (_, currentWindow) {
                     currentWindow.on('enter-full-screen', function () {
                         lastElectronBrowserWindow = currentWindow;
                         emitChange();
@@ -990,7 +1109,8 @@ function getEnabled() {
     if (Platform.crossPlatformFramework === CrossPlatformFramework.Electron) {
         try {
             var electron = require('electron');
-            return typeof electron.BrowserWindow.prototype.setFullScreen === 'function';
+            var browserWindow = electron.BrowserWindow;
+            return typeof browserWindow.prototype.setFullScreen === 'function';
         }
         catch (_) {
             return false;
@@ -1018,7 +1138,8 @@ function getElement() {
             return lastElectronBrowserWindow;
         try {
             var electron = require('electron');
-            var allWindows = electron.BrowserWindow.getAllWindows();
+            var browserWindow = electron.BrowserWindow;
+            var allWindows = browserWindow.getAllWindows();
             for (var i = 0; i < allWindows.length; i++) {
                 var currentWindow = allWindows[i];
                 if (currentWindow.isFullScreen() || (Platform.os.name === OS.MacOS && typeof currentWindow.isSimpleFullScreen === 'function' && currentWindow.isSimpleFullScreen()))