native-fn 1.2.2 → 1.3.1

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

@@ -82,8 +82,8 @@ export interface DirectoryOptions {
     startIn?: ExplorerStartIn;
 }
 export interface FileWithPath {
-    file: File;
-    relativePath: string;
+    readonly file: File;
+    readonly relativePath: string;
 }
 export interface CameraOptions {
     type?: CameraType;
@@ -175,7 +175,7 @@ export declare interface OpenInstance {
     contact(options?: ContactOptions): Promise<Contact[]>;
     share(options: ShareData): Promise<void>;
     calendar(options: CalendarOptions): void;
-    supported: {
+    readonly supported: {
         get intent(): boolean;
         get universal(): boolean;
         get setting(): boolean;
@@ -185,15 +185,15 @@ export declare interface OpenInstance {
         get share(): boolean;
         get calendar(): boolean;
     };
-    Constants: {
-        AppOpenState: typeof AppOpenState;
-        SettingType: typeof SettingType;
-        CameraType: typeof CameraType;
-        CaptureType: typeof CaptureType;
+    readonly Constants: {
+        readonly AppOpenState: typeof AppOpenState;
+        readonly SettingType: typeof SettingType;
+        readonly CameraType: typeof CameraType;
+        readonly CaptureType: typeof CaptureType;
     };
-    Errors: {
-        URLOpenError: typeof URLOpenError;
-        NotSupportedError: typeof NotSupportedError;
-        UserCancelledError: typeof UserCancelledError;
+    readonly Errors: {
+        readonly URLOpenError: typeof URLOpenError;
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly UserCancelledError: typeof UserCancelledError;
     };
 }

package/dist/plugin/fullscreen/src/plugin/permission/constants/index.d.ts

@@ -12,7 +12,9 @@ export declare enum PermissionType {
     Camera = "camera",
     ClipboardRead = "clipboard-read",
     Microphone = "microphone",
-    MIDI = "midi"
+    MIDI = "midi",
+    DeviceOrientation = "device-orientation",
+    DeviceMotion = "device-motion"
 }
 export declare enum PermissionState {
     Grant = "grant",

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

@@ -1,11 +1,14 @@
 import { PermissionState, PermissionType } from "../constants";
+import { NotSupportedError } from "../../../errors/not-supported-error";
 export declare interface PermissionInstance {
     get supported(): boolean;
     request(type: PermissionType): Promise<PermissionState>;
     check(type: PermissionType): Promise<PermissionState>;
-    Constants: {
-        PermissionType: typeof PermissionType;
-        PermissionState: typeof PermissionState;
+    readonly Constants: {
+        readonly PermissionType: typeof PermissionType;
+        readonly PermissionState: typeof PermissionState;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
-    Errors: {};
 }

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

@@ -11,14 +11,14 @@ export declare interface PipInstance {
     onChange(target: HTMLVideoElement, listener: (payload: PipEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onError(listener: (payload: PipEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onError(target: HTMLVideoElement, listener: (payload: PipEventPayload) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        InvalidStateError: typeof InvalidStateError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly InvalidStateError: typeof InvalidStateError;
     };
 }
 export declare interface PipEventPayload {
-    nativeEvent: Event;
-    element: HTMLVideoElement;
-    isActive: boolean;
+    readonly nativeEvent: Event;
+    readonly element: HTMLVideoElement;
+    readonly isActive: boolean;
 }

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

@@ -34,7 +34,7 @@ export declare enum Browsers {
     IE = "IE",
     SamsungInternet = "SamsungInternet"
 }
-export declare const USER_AGENT: string;
+export declare let USER_AGENT: string;
 export declare const HIGH_ENTROPY_BRAND_NAME_MAP: Record<string, string>;
 export declare const RTL_LANGUAGES: string[];
 export declare const OS_RESOLVER_MAP: [RegExp, OS, VersionResolver?][];

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

@@ -14,24 +14,24 @@ export declare interface PlatformInstance {
     get isNode(): boolean;
     get isStandalone(): boolean;
     get isWebview(): boolean;
-    Constants: {
-        OS: typeof OS;
-        Engines: typeof Engines;
-        Browsers: typeof Browsers;
-        Devices: typeof Devices;
+    readonly Constants: {
+        readonly OS: typeof OS;
+        readonly Engines: typeof Engines;
+        readonly Browsers: typeof Browsers;
+        readonly Devices: typeof Devices;
     };
-    Errors: {};
+    readonly Errors: {};
 }
 export declare interface NameVersionPair<T> {
-    name: T;
-    version: string;
+    readonly name: T;
+    readonly version: string;
 }
 export declare interface Locale {
-    language: string | null;
-    languages: string[];
-    timezone: string | null;
-    offset: number;
-    isRTL: boolean;
+    readonly language: string | null;
+    readonly languages: readonly string[];
+    readonly timezone: string | null;
+    readonly offset: number;
+    readonly isRTL: boolean;
 }
 export interface GPUAdapterInfo {
     readonly vendor?: string;

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

@@ -1,6 +1,6 @@
 export declare interface ThemeInstance {
     get value(): string | undefined;
     set value(color: string | undefined);
-    Constants: {};
-    Errors: {};
+    readonly Constants: {};
+    readonly Errors: {};
 }

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

@@ -3,8 +3,8 @@ export declare interface VibrationInstance {
     get supported(): boolean;
     run(pattern: number | number[]): boolean;
     stop(): boolean;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/fullscreen/src/types/subscription-manager.d.ts

@@ -1,4 +1,4 @@
-export declare interface SubscriptionManager<T, U> {
-    emit: (value: U) => void;
-    subscribe: (listener: (value: U) => void, options?: AddEventListenerOptions) => () => void;
+export declare interface SubscriptionManager<T> {
+    emit: (value: T) => void;
+    subscribe: (listener: (value: T) => void, options?: AddEventListenerOptions) => () => void;
 }

package/dist/plugin/fullscreen/src/utils/create-subscription-manager.d.ts

@@ -1,2 +1,2 @@
 import { SubscriptionManager } from "../types/subscription-manager";
-export default function createSubscriptionManager<T, U>(attach: () => void, detach: () => void): SubscriptionManager<T, U>;
+export default function createSubscriptionManager<T>(attach: () => void, detach: () => void): SubscriptionManager<T>;

package/dist/plugin/fullscreen/src/utils/insert-sort.d.ts

@@ -0,0 +1 @@
+export default function insertionSort(arr: number[]): void;

package/dist/plugin/geolocation/index.cjs

@@ -92,6 +92,8 @@ var PermissionType;
     PermissionType["ClipboardRead"] = "clipboard-read";
     PermissionType["Microphone"] = "microphone";
     PermissionType["MIDI"] = "midi";
+    PermissionType["DeviceOrientation"] = "device-orientation";
+    PermissionType["DeviceMotion"] = "device-motion";
 })(PermissionType || (PermissionType = {}));
 var PermissionState;
 (function (PermissionState) {
@@ -123,182 +125,6 @@ var GET_USER_MEDIA = (function () {
     }
 })();
 
-var Permission = {
-    get supported() {
-        return supported$1();
-    },
-    request: request$1,
-    check: check,
-    Constants: {
-        PermissionType: PermissionType,
-        PermissionState: PermissionState,
-    },
-    Errors: {},
-};
-function supported$1() {
-    return typeof globalThis.navigator.permissions !== 'undefined';
-}
-function request$1(type) {
-    var instance = this;
-    return new Promise(function (resolve) {
-        function resolveAfterCheck() {
-            instance.check(type).then(resolve);
-        }
-        instance.check(type)
-            .then(function (state) {
-            if (state === PermissionState.Grant)
-                return resolve(state);
-            switch (type) {
-                case PermissionType.Notification:
-                    if (typeof globalThis.Notification === 'undefined')
-                        return resolve(PermissionState.Unsupported);
-                    globalThis.Notification.requestPermission().then(function (value) {
-                        switch (value) {
-                            case 'default':
-                                return resolve(PermissionState.Prompt);
-                            case 'granted':
-                                return resolve(PermissionState.Grant);
-                            case 'denied':
-                                return resolve(PermissionState.Denied);
-                            default:
-                                resolveAfterCheck();
-                        }
-                    });
-                    break;
-                case PermissionType.Geolocation:
-                    if (typeof globalThis.navigator.geolocation === 'undefined')
-                        return resolve(PermissionState.Unsupported);
-                    globalThis.navigator.geolocation.getCurrentPosition(resolveAfterCheck, resolveAfterCheck);
-                    break;
-                case PermissionType.Microphone:
-                case PermissionType.Camera:
-                    if (typeof GET_USER_MEDIA === 'undefined')
-                        return resolve(PermissionState.Unsupported);
-                    GET_USER_MEDIA({
-                        video: type === PermissionType.Camera,
-                        audio: type === PermissionType.Microphone,
-                    })
-                        .then(function (stream) {
-                        var tracks = stream.getTracks();
-                        for (var i = 0; i < tracks.length; i++)
-                            tracks[i].stop();
-                        resolveAfterCheck();
-                    })
-                        .catch(resolveAfterCheck);
-                    break;
-                case PermissionType.ClipboardRead:
-                    if (typeof globalThis.navigator.clipboard === 'undefined' || typeof globalThis.navigator.clipboard.read === 'undefined')
-                        return resolve(PermissionState.Unsupported);
-                    globalThis.navigator.clipboard.read()
-                        .then(resolveAfterCheck)
-                        .catch(resolveAfterCheck);
-                    break;
-                case PermissionType.MIDI:
-                    if (typeof globalThis.navigator.requestMIDIAccess === 'undefined')
-                        return resolve(PermissionState.Unsupported);
-                    globalThis.navigator.requestMIDIAccess()
-                        .then(resolveAfterCheck)
-                        .catch(resolveAfterCheck);
-                    break;
-                default:
-                    return resolve(PermissionState.Unsupported);
-            }
-        });
-    });
-}
-function check(type) {
-    return new Promise(function (resolve) {
-        if (typeof globalThis.navigator.permissions === 'undefined')
-            return resolve(PermissionState.Unsupported);
-        globalThis.navigator.permissions.query({ name: type })
-            .then(function (status) {
-            switch (status.state) {
-                case 'prompt':
-                    return resolve(PermissionState.Prompt);
-                case 'granted':
-                    return resolve(PermissionState.Grant);
-                case 'denied':
-                    return resolve(PermissionState.Denied);
-                default:
-                    return resolve(PermissionState.Unsupported);
-            }
-        });
-    });
-}
-
-var PermissionNotGrantedError = createCustomError('PermissionNotGrantedError');
-
-function keys(object) {
-    var keys = [];
-    for (var key in object)
-        if (object.hasOwnProperty(key))
-            keys.push(key);
-    return keys;
-}
-
-function request(url, options) {
-    return new Promise(function (resolve) {
-        var method = 'GET';
-        var headers = {};
-        var body = undefined;
-        if (typeof globalThis.fetch !== 'undefined') {
-            fetch(url, {
-                method: method,
-                headers: headers,
-                body: body
-            })
-                .then(function (response) {
-                if (!response.ok) {
-                    resolve(undefined);
-                    return Promise.resolve();
-                }
-                return response
-                    .json()
-                    .then(function (data) {
-                    resolve(data);
-                })
-                    .catch(function () {
-                    resolve(undefined);
-                });
-            })
-                .catch(function () {
-                resolve(undefined);
-            });
-            return;
-        }
-        if (typeof XMLHttpRequest !== "undefined") {
-            var xhr_1 = new XMLHttpRequest();
-            xhr_1.open(method, url, true);
-            var headerKeys = keys(headers);
-            for (var i = 0; i < headerKeys.length; i++) {
-                var headerKey = headerKeys[i];
-                xhr_1.setRequestHeader(headerKey, headers[headerKey]);
-            }
-            xhr_1.onreadystatechange = function () {
-                if (xhr_1.readyState !== 4)
-                    return;
-                if (xhr_1.status >= 200 && xhr_1.status < 300) {
-                    try {
-                        resolve(JSON.parse(xhr_1.responseText));
-                    }
-                    catch (_) {
-                        resolve(undefined);
-                    }
-                }
-                else {
-                    resolve(undefined);
-                }
-            };
-            xhr_1.onerror = function () {
-                resolve(undefined);
-            };
-            xhr_1.send(body);
-            return;
-        }
-        resolve(undefined);
-    });
-}
-
 var IE_WRAPPER_STORE = [];
 var MEDIA_QUERY_LIST_WRAPPER_STORE = [];
 function isEventListenerCallback(callback) {
@@ -505,6 +331,249 @@ var EventListener = {
     },
 };
 
+var Permission = {
+    get supported() {
+        return supported$1();
+    },
+    request: request$1,
+    check: check,
+    Constants: {
+        PermissionType: PermissionType,
+        PermissionState: PermissionState,
+    },
+    Errors: {
+        NotSupportedError: NotSupportedError,
+    },
+};
+function toPermissionState(permission) {
+    switch (permission) {
+        case 'granted':
+            return PermissionState.Grant;
+        case 'denied':
+            return PermissionState.Denied;
+        case 'prompt':
+        case 'default':
+            return PermissionState.Prompt;
+        default:
+            return PermissionState.Unsupported;
+    }
+}
+function toSafariSensorEventMap(type) {
+    switch (type) {
+        case PermissionType.DeviceOrientation:
+            return {
+                event: globalThis.DeviceOrientationEvent,
+                type: 'deviceorientation',
+            };
+        case PermissionType.DeviceMotion:
+            return {
+                event: globalThis.DeviceMotionEvent,
+                type: 'devicemotion',
+            };
+        default:
+            return undefined;
+    }
+}
+function supported$1() {
+    return typeof globalThis.navigator.permissions !== 'undefined';
+}
+function request$1(type) {
+    var instance = this;
+    return new Promise(function (resolve, reject) {
+        function resolveAfterCheck() {
+            instance.check(type).then(resolve);
+        }
+        instance.check(type)
+            .then(function (state) {
+            if (state === PermissionState.Grant)
+                return resolve(state);
+            switch (type) {
+                case PermissionType.Notification:
+                    if (typeof globalThis.Notification === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.Notification.requestPermission().then(function (permission) {
+                        resolve(toPermissionState(permission));
+                    });
+                    break;
+                case PermissionType.Geolocation:
+                    if (typeof globalThis.navigator.geolocation === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.geolocation.getCurrentPosition(resolveAfterCheck, resolveAfterCheck);
+                    break;
+                case PermissionType.Microphone:
+                case PermissionType.Camera:
+                    if (typeof GET_USER_MEDIA === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    GET_USER_MEDIA({
+                        video: type === PermissionType.Camera,
+                        audio: type === PermissionType.Microphone,
+                    })
+                        .then(function (stream) {
+                        var tracks = stream.getTracks();
+                        for (var i = 0; i < tracks.length; i++)
+                            tracks[i].stop();
+                        resolveAfterCheck();
+                    })
+                        .catch(resolveAfterCheck);
+                    break;
+                case PermissionType.ClipboardRead:
+                    if (typeof globalThis.navigator.clipboard === 'undefined' || typeof globalThis.navigator.clipboard.read === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.clipboard.read()
+                        .then(resolveAfterCheck)
+                        .catch(resolveAfterCheck);
+                    break;
+                case PermissionType.MIDI:
+                    if (typeof globalThis.navigator.requestMIDIAccess === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    globalThis.navigator.requestMIDIAccess()
+                        .then(resolveAfterCheck)
+                        .catch(resolveAfterCheck);
+                    break;
+                case PermissionType.DeviceOrientation:
+                case PermissionType.DeviceMotion:
+                    var sensorEventMap = toSafariSensorEventMap(type);
+                    if (typeof sensorEventMap === 'undefined' || typeof sensorEventMap.event === 'undefined')
+                        return resolve(PermissionState.Unsupported);
+                    if (typeof sensorEventMap.event.requestPermission !== 'function')
+                        return resolve(PermissionState.Grant);
+                    try {
+                        sensorEventMap.event.requestPermission()
+                            .then(function (permission) {
+                            resolve(toPermissionState(permission));
+                        });
+                    }
+                    catch (_) {
+                        return reject(new NotSupportedError('\'DeviceOrientationEvent.requestPermission()\' must be called within a user gesture context.'));
+                    }
+                    break;
+                default:
+                    return resolve(PermissionState.Unsupported);
+            }
+        });
+    });
+}
+function check(type) {
+    if (type === PermissionType.DeviceOrientation || type === PermissionType.DeviceMotion) {
+        return new Promise(function (resolve) {
+            var sensorEventMap = toSafariSensorEventMap(type);
+            if (typeof sensorEventMap === 'undefined' || typeof sensorEventMap.event === 'undefined')
+                return resolve(PermissionState.Unsupported);
+            if (typeof sensorEventMap.event.requestPermission !== 'function')
+                return resolve(PermissionState.Grant);
+            var granted = false;
+            EventListener.add(globalThis, {
+                type: sensorEventMap.type,
+                callback: function () {
+                    granted = true;
+                },
+                options: { once: true }
+            });
+            setTimeout(function () {
+                if (granted)
+                    return resolve(PermissionState.Grant);
+                sensorEventMap.event.requestPermission()
+                    .then(function (permission) {
+                    resolve(toPermissionState(permission));
+                })
+                    .catch(function () {
+                    resolve(PermissionState.Prompt);
+                });
+            }, 50);
+        });
+    }
+    return new Promise(function (resolve) {
+        if (typeof globalThis.navigator.permissions === 'undefined')
+            return resolve(PermissionState.Unsupported);
+        globalThis.navigator.permissions.query({ name: type })
+            .then(function (status) {
+            switch (status.state) {
+                case 'prompt':
+                    return resolve(PermissionState.Prompt);
+                case 'granted':
+                    return resolve(PermissionState.Grant);
+                case 'denied':
+                    return resolve(PermissionState.Denied);
+                default:
+                    return resolve(PermissionState.Unsupported);
+            }
+        });
+    });
+}
+
+var PermissionNotGrantedError = createCustomError('PermissionNotGrantedError');
+
+function keys(object) {
+    var keys = [];
+    for (var key in object)
+        if (object.hasOwnProperty(key))
+            keys.push(key);
+    return keys;
+}
+
+function request(url, options) {
+    return new Promise(function (resolve) {
+        var method = 'GET';
+        var headers = {};
+        var body = undefined;
+        if (typeof globalThis.fetch !== 'undefined') {
+            fetch(url, {
+                method: method,
+                headers: headers,
+                body: body
+            })
+                .then(function (response) {
+                if (!response.ok) {
+                    resolve(undefined);
+                    return Promise.resolve();
+                }
+                return response
+                    .json()
+                    .then(function (data) {
+                    resolve(data);
+                })
+                    .catch(function () {
+                    resolve(undefined);
+                });
+            })
+                .catch(function () {
+                resolve(undefined);
+            });
+            return;
+        }
+        if (typeof XMLHttpRequest !== "undefined") {
+            var xhr_1 = new XMLHttpRequest();
+            xhr_1.open(method, url, true);
+            var headerKeys = keys(headers);
+            for (var i = 0; i < headerKeys.length; i++) {
+                var headerKey = headerKeys[i];
+                xhr_1.setRequestHeader(headerKey, headers[headerKey]);
+            }
+            xhr_1.onreadystatechange = function () {
+                if (xhr_1.readyState !== 4)
+                    return;
+                if (xhr_1.status >= 200 && xhr_1.status < 300) {
+                    try {
+                        resolve(JSON.parse(xhr_1.responseText));
+                    }
+                    catch (_) {
+                        resolve(undefined);
+                    }
+                }
+                else {
+                    resolve(undefined);
+                }
+            };
+            xhr_1.onerror = function () {
+                resolve(undefined);
+            };
+            xhr_1.send(body);
+            return;
+        }
+        resolve(undefined);
+    });
+}
+
 function createSubscriptionManager(attach, detach) {
     var entries = [];
     function removeEntry(entry) {
@@ -532,6 +601,8 @@ function createSubscriptionManager(attach, detach) {
         },
         subscribe: function (listener, options) {
             if (options === void 0) { options = {}; }
+            if (typeof options.signal !== 'undefined' && options.signal.aborted)
+                return function () { };
             var entry = { fn: listener, once: false };
             if (typeof options.once !== 'undefined')
                 entry.once = options.once;
@@ -550,12 +621,8 @@ function createSubscriptionManager(attach, detach) {
                 EventListener.remove(entry.signal, { type: 'abort', callback: cleanup });
                 removeEntry(entry);
             };
-            if (typeof entry.signal !== 'undefined') {
-                if (entry.signal.aborted)
-                    removeEntry(entry);
-                else
-                    EventListener.add(entry.signal, { type: 'abort', callback: cleanup });
-            }
+            if (typeof entry.signal !== 'undefined')
+                EventListener.add(entry.signal, { type: 'abort', callback: cleanup });
             return function unsubscribe() {
                 removeEntry(entry);
             };

package/dist/plugin/geolocation/index.d.ts

@@ -6,10 +6,10 @@ declare interface GeolocationInstance {
     get supported(): boolean;
     get value(): Promise<GeolocationCoordinates>;
     onChange(listener: (coordinates: GeolocationCoordinates) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
     };
 }