native-fn 1.2.2 → 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) {
@@ -530,6 +599,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;
@@ -548,12 +619,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/src/plugin/appearance/constants/index.d.ts

@@ -3,6 +3,6 @@ export declare enum Appearances {
     Light = "light",
     Dark = "dark"
 }
-export declare let MEDIA_QUERY_LIST: MediaQueryList;
+export declare let PREFERS_COLOR_SCHEME_MEDIA_QUERY_LIST: MediaQueryList;
 export declare const CONTEXT: CanvasRenderingContext2D | null;
 export declare const SVG_PIXEL_DATA_URL: string;

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,8 +1,12 @@
-import { Dimensions } from "../types";
 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': {
@@ -40,5 +44,5 @@ export declare const ENV_PRESETS: {
         readonly left: "viewport-segment-left";
     };
 };
-export declare const FALLBACK_DIMENSION: Dimensions;
-export declare let MEDIA_QUERY_LIST: MediaQueryList;
+export declare let ORIENTATION_MEDIA_QUERY_LIST: MediaQueryList;
+export declare let DEVICE_POSTURE_MEDIA_QUERY_LIST: MediaQueryList;

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

@@ -1,3 +1,18 @@
 import { DimensionInstance } from "../types";
+declare global {
+    interface DOMRectReadOnly {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    }
+    interface VisualViewport {
+        readonly segments?: DOMRectReadOnly[];
+    }
+}
 declare const Dimension: DimensionInstance;
 export default Dimension;

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

@@ -1,34 +1,62 @@
 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 EnvironmentPresetAttr<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
+export type EnvironmentPresetAttribute<K extends EnvironmentPresetKey> = keyof typeof ENV_PRESETS[K];
 export type EnvironmentPresetValues<K extends EnvironmentPresetKey> = {
-    [P in EnvironmentPresetAttr<K>]: number;
+    [P in EnvironmentPresetAttribute<K>]: number;
 };
-export declare interface DimensionInstance {
-    get value(): Dimensions;
-    environment: Environment;
-    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
-    Constants: {
-        Orientation: typeof Orientation;
-    };
-    Errors: {};
+export declare interface Environment {
+    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 Dimensions {
-    outerWidth: number;
-    outerHeight: number;
-    innerWidth: number;
-    innerHeight: number;
-    scale: number;
-    orientation: Orientation;
+export declare interface SegmentsObserver {
+    get value(): EnvironmentPresetValues<'viewport-segment'>[];
+    onChange(listener: (value: EnvironmentPresetValues<'viewport-segment'>[]) => void, options?: AddEventListenerOptions): () => void;
+    useCssVariable(prefix: string): () => void;
 }
-export declare interface EnvironmentPreset<K extends EnvironmentPresetKey> {
+export declare type EnvironmentObserver<K extends EnvironmentPresetKey> = K extends 'viewport-segment' ? SegmentsObserver : {
     get value(): EnvironmentPresetValues<K>;
     onChange(listener: (value: EnvironmentPresetValues<K>) => void, options?: AddEventListenerOptions): () => void;
+    useCssVariable(prefix: string): () => void;
+};
+export declare interface Dimensions {
+    readonly outerWidth: number;
+    readonly outerHeight: number;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly scale: number;
 }
-export declare interface Environment {
-    safeAreaInset: EnvironmentPreset<'safe-area-inset'>;
-    safeAreaMaxInset: EnvironmentPreset<'safe-area-max-inset'>;
-    keyboardInset: EnvironmentPreset<'keyboard-inset'>;
-    titlebarArea: EnvironmentPreset<'titlebar-area'>;
-    viewportSegment: EnvironmentPreset<'viewport-segment'>;
+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;
+    readonly environment: Environment;
+    readonly screenOrientation: ScreenOrientationInstance;
+    readonly deviceOrientation: DeviceOrientationInstance;
+    onChange(listener: (dimension: Dimensions) => void, options?: AddEventListenerOptions): () => void;
+    readonly Constants: {
+        readonly Orientation: typeof Orientation;
+    };
+    readonly Errors: {
+        readonly NotSupportedError: typeof NotSupportedError;
+        readonly PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
 }