native-fn 1.3.0 → 1.3.1

package/dist/plugin/geolocation/index.mjs

@@ -90,6 +90,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) {
@@ -121,182 +123,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) {
@@ -503,6 +329,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) {

package/dist/plugin/geolocation/src/plugin/appearance/types/appearance.d.ts

@@ -2,8 +2,8 @@ import { Appearances } from "../constants";
 export declare interface AppearanceInstance {
     get value(): Appearances;
     onChange(listener: (appearance: Appearances) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Appearances: typeof Appearances;
+    readonly Constants: {
+        readonly Appearances: typeof Appearances;
     };
-    Errors: {};
+    readonly Errors: {};
 }

package/dist/plugin/geolocation/src/plugin/badge/types/badge.d.ts

@@ -3,8 +3,8 @@ export declare interface BadgeInstance {
     get supported(): boolean;
     set(contents: number): Promise<void>;
     clear(): Promise<void>;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

package/dist/plugin/geolocation/src/plugin/battery/types/battery.d.ts

@@ -19,8 +19,8 @@ export declare interface BatteryInstance {
     get supported(): boolean;
     get value(): Promise<BatteryManager>;
     onChange(listener: (battery: BatteryManager) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
     };
 }

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

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

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

@@ -1,7 +1,12 @@
 export declare enum Orientation {
-    Portrait = "portrait",
-    Landscape = "landscape",
-    Unknown = "unknown"
+    PortraitPrimary = "portrait-primary",
+    PortraitSecondary = "portrait-secondary",
+    LandscapePrimary = "landscape-primary",
+    LandscapeSecondary = "landscape-secondary"
+}
+export declare namespace Orientation {
+    function isLandscape(orientation: Orientation): boolean;
+    function isPortrait(orientation: Orientation): boolean;
 }
 export declare const ENV_PRESETS: {
     readonly 'safe-area-inset': {

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

@@ -1,15 +1,17 @@
 import { ENV_PRESETS, Orientation } from "../constants";
+import { NotSupportedError } from "../../../errors/not-supported-error";
+import { PermissionNotGrantedError } from "../../../errors/permission-not-granted-error";
 export type EnvironmentPresetKey = keyof typeof ENV_PRESETS;
 export type EnvironmentPresetAttribute<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
 export type EnvironmentPresetValues<K extends EnvironmentPresetKey> = {
     [P in EnvironmentPresetAttribute<K>]: number;
 };
 export declare interface Environment {
-    safeAreaInset: EnvironmentObserver<'safe-area-inset'>;
-    safeAreaMaxInset: EnvironmentObserver<'safe-area-max-inset'>;
-    keyboardInset: EnvironmentObserver<'keyboard-inset'>;
-    titlebarArea: EnvironmentObserver<'titlebar-area'>;
-    viewportSegment: EnvironmentObserver<'viewport-segment'>;
+    readonly safeAreaInset: EnvironmentObserver<'safe-area-inset'>;
+    readonly safeAreaMaxInset: EnvironmentObserver<'safe-area-max-inset'>;
+    readonly keyboardInset: EnvironmentObserver<'keyboard-inset'>;
+    readonly titlebarArea: EnvironmentObserver<'titlebar-area'>;
+    readonly viewportSegment: EnvironmentObserver<'viewport-segment'>;
 }
 export declare interface SegmentsObserver {
     get value(): EnvironmentPresetValues<'viewport-segment'>[];
@@ -22,19 +24,39 @@ export declare type EnvironmentObserver<K extends EnvironmentPresetKey> = K exte
     useCssVariable(prefix: string): () => void;
 };
 export declare interface Dimensions {
-    outerWidth: number;
-    outerHeight: number;
-    innerWidth: number;
-    innerHeight: number;
-    scale: number;
-    orientation: Orientation;
+    readonly outerWidth: number;
+    readonly outerHeight: number;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly scale: number;
+}
+export declare interface DeviceOrientationValue {
+    readonly alpha: number | null;
+    readonly beta: number | null;
+    readonly gamma: number | null;
+    readonly absolute: boolean;
+}
+export declare interface DeviceOrientationInstance {
+    get supported(): boolean;
+    readonly value: Promise<DeviceOrientationValue>;
+    onChange(listener: (value: DeviceOrientationValue) => void, options?: AddEventListenerOptions): () => void;
+}
+export declare interface ScreenOrientationInstance {
+    get supported(): boolean;
+    readonly value: Orientation;
+    onChange(listener: (value: Orientation) => void, options?: AddEventListenerOptions): () => void;
 }
 export declare interface DimensionInstance {
     get value(): Dimensions;
-    environment: Environment;
+    readonly environment: Environment;
+    readonly screenOrientation: ScreenOrientationInstance;
+    readonly deviceOrientation: DeviceOrientationInstance;
     onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Orientation: typeof Orientation;
+    readonly Constants: {
+        readonly Orientation: typeof Orientation;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
     };
-    Errors: {};
 }

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

@@ -11,14 +11,14 @@ export declare interface FullscreenInstance {
     onChange(target: Element, listener: (payload: FullscreenEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onError(listener: (payload: FullscreenEventPayload) => void, options?: AddEventListenerOptions): () => void;
     onChange(target: Element, listener: (payload: FullscreenEventPayload) => 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 FullscreenEventPayload {
-    nativeEvent: Event;
-    element: Element;
-    isActive: boolean;
+    readonly nativeEvent: Event;
+    readonly element: Element;
+    readonly isActive: boolean;
 }

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

@@ -4,9 +4,9 @@ export 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;
     };
 }

package/dist/plugin/geolocation/src/plugin/notification/types/notification.d.ts

@@ -19,9 +19,9 @@ export interface NotificationOptions {
 export declare interface NotificationInstance {
     send(options: NotificationOptions): Promise<Notification>;
     get supported(): boolean;
-    Constants: {};
-    Errors: {
-        NotSupportedError: typeof NotSupportedError;
-        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    readonly Constants: {};
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
     };
 }

package/dist/plugin/geolocation/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;
     };
 }