native-fn 1.1.2 → 1.1.4

package/dist/plugin/notification/index.cjs

@@ -0,0 +1,268 @@
+'use strict';
+
+function createCustomError(name, Base) {
+    if (Base === void 0) { Base = Error; }
+    function CustomError(message) {
+        if (!(this instanceof CustomError))
+            return new CustomError(message);
+        var error = (function () {
+            if (typeof message === 'undefined')
+                return new Base('');
+            return new Base(message);
+        })();
+        if (typeof Object.setPrototypeOf === 'function')
+            Object.setPrototypeOf(error, CustomError.prototype);
+        else
+            error.__proto__ = CustomError.prototype;
+        error.name = name;
+        if (typeof message !== 'undefined')
+            error.message = message;
+        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+            try {
+                Object.defineProperty(error, Symbol.toStringTag, {
+                    value: name,
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            catch (_) {
+            }
+        }
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(error, CustomError);
+        }
+        else if (Base.captureStackTrace && typeof Base.captureStackTrace === 'function') {
+            Base.captureStackTrace(error, CustomError);
+        }
+        else {
+            try {
+                var tempError = new Base();
+                if (tempError.stack)
+                    error.stack = tempError.stack;
+            }
+            catch (_) {
+            }
+        }
+        return error;
+    }
+    CustomError.prototype = Object.create(Base.prototype, {
+        constructor: {
+            value: CustomError,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        }
+    });
+    try {
+        Object.defineProperty(CustomError.prototype, 'name', {
+            value: name,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+        try {
+            CustomError.prototype.name = name;
+        }
+        catch (_) {
+        }
+    }
+    try {
+        Object.defineProperty(CustomError, 'name', {
+            value: name,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+    }
+    return CustomError;
+}
+
+var NotSupportedError = createCustomError('NotSupportedError');
+
+var PermissionType;
+(function (PermissionType) {
+    PermissionType["Notification"] = "notifications";
+    PermissionType["Geolocation"] = "geolocation";
+    PermissionType["Camera"] = "camera";
+    PermissionType["Microphone"] = "microphone";
+    PermissionType["MIDI"] = "midi";
+})(PermissionType || (PermissionType = {}));
+var PermissionState;
+(function (PermissionState) {
+    PermissionState["Grant"] = "grant";
+    PermissionState["Denied"] = "denied";
+    PermissionState["Prompt"] = "prompt";
+    PermissionState["Unsupported"] = "unsupported";
+})(PermissionState || (PermissionState = {}));
+var GET_USER_MEDIA = (function () {
+    if (typeof globalThis.navigator.mediaDevices !== 'undefined' && typeof globalThis.navigator.mediaDevices.getUserMedia !== 'undefined')
+        return globalThis.navigator.mediaDevices.getUserMedia.bind(globalThis.navigator.mediaDevices);
+    var legacy = (function () {
+        if (typeof globalThis.navigator.getUserMedia !== 'undefined')
+            return globalThis.navigator.getUserMedia;
+        if (typeof globalThis.navigator.webkitGetUserMedia !== 'undefined')
+            return globalThis.navigator.webkitGetUserMedia;
+        if (typeof globalThis.navigator.mozGetUserMedia !== 'undefined')
+            return globalThis.navigator.mozGetUserMedia;
+        if (typeof globalThis.navigator.msGetUserMedia !== 'undefined')
+            return globalThis.navigator.msGetUserMedia;
+    })();
+    if (typeof legacy !== 'undefined') {
+        return function legacyUserMedia(constraints) {
+            if (constraints === void 0) { constraints = {}; }
+            return new Promise(function (resolve, reject) {
+                legacy.call(globalThis.navigator, constraints, resolve, reject);
+            });
+        };
+    }
+})();
+
+var Permission = {
+    request: request,
+    check: check,
+    Constants: {
+        PermissionType: PermissionType,
+        PermissionState: PermissionState,
+    },
+    Errors: {},
+};
+function request(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.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');
+
+var Notification = {
+    send: send,
+    get supported() {
+        return supported();
+    },
+    Constants: {},
+    Errors: {
+        NotSupportedError: NotSupportedError,
+        PermissionNotGrantedError: PermissionNotGrantedError,
+    },
+};
+function send(options) {
+    return new Promise(function (resolve, reject) {
+        if (!supported())
+            return reject(new NotSupportedError('\'window.Notification\' does not supported.'));
+        Permission
+            .request(PermissionType.Notification)
+            .then(function (state) {
+            if (state === PermissionState.Grant) {
+                var constructorOptions = {
+                    badge: options.badge,
+                    body: options.body,
+                    data: options.data,
+                    dir: options.dir,
+                    icon: options.icon,
+                    lang: options.lang,
+                    requireInteraction: options.requireInteraction,
+                    silent: options.silent,
+                    tag: options.tag,
+                };
+                var notification = new globalThis.Notification(options.title, constructorOptions);
+                if (typeof options.onClick !== 'undefined')
+                    notification.onclick = options.onClick;
+                if (typeof options.onShow !== 'undefined')
+                    notification.onshow = options.onShow;
+                if (typeof options.onClose !== 'undefined')
+                    notification.onclose = options.onClose;
+                if (typeof options.onError !== 'undefined')
+                    notification.onerror = options.onError;
+                resolve(notification);
+            }
+            else {
+                reject(new PermissionNotGrantedError('\'notification\' permission is not granted.'));
+            }
+        });
+    });
+}
+function supported() {
+    return typeof globalThis.Notification !== 'undefined';
+}
+
+module.exports = Notification;

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

@@ -0,0 +1,34 @@
+declare const NotSupportedError: ErrorConstructor;
+
+declare const PermissionNotGrantedError: ErrorConstructor;
+
+interface NotificationOptions {
+    title: string;
+    badge?: string;
+    body?: string;
+    data?: any;
+    dir?: NotificationDirection;
+    icon?: string;
+    lang?: string;
+    requireInteraction?: boolean;
+    silent?: boolean | null;
+    tag?: string;
+    onClick?: ((this: Notification, event: Event) => any);
+    onClose?: ((this: Notification, event: Event) => any);
+    onError?: ((this: Notification, event: Event) => any);
+    onShow?: ((this: Notification, event: Event) => any);
+}
+declare interface NotificationInstance {
+    send(options: NotificationOptions): Promise<Notification>;
+    get supported(): boolean;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
+}
+
+declare const Notification$1: NotificationInstance;
+
+export { Notification$1 as default };
+export type { NotificationInstance, NotificationOptions };

package/dist/plugin/notification/index.mjs

@@ -0,0 +1,266 @@
+function createCustomError(name, Base) {
+    if (Base === void 0) { Base = Error; }
+    function CustomError(message) {
+        if (!(this instanceof CustomError))
+            return new CustomError(message);
+        var error = (function () {
+            if (typeof message === 'undefined')
+                return new Base('');
+            return new Base(message);
+        })();
+        if (typeof Object.setPrototypeOf === 'function')
+            Object.setPrototypeOf(error, CustomError.prototype);
+        else
+            error.__proto__ = CustomError.prototype;
+        error.name = name;
+        if (typeof message !== 'undefined')
+            error.message = message;
+        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+            try {
+                Object.defineProperty(error, Symbol.toStringTag, {
+                    value: name,
+                    writable: false,
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            catch (_) {
+            }
+        }
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(error, CustomError);
+        }
+        else if (Base.captureStackTrace && typeof Base.captureStackTrace === 'function') {
+            Base.captureStackTrace(error, CustomError);
+        }
+        else {
+            try {
+                var tempError = new Base();
+                if (tempError.stack)
+                    error.stack = tempError.stack;
+            }
+            catch (_) {
+            }
+        }
+        return error;
+    }
+    CustomError.prototype = Object.create(Base.prototype, {
+        constructor: {
+            value: CustomError,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        }
+    });
+    try {
+        Object.defineProperty(CustomError.prototype, 'name', {
+            value: name,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+        try {
+            CustomError.prototype.name = name;
+        }
+        catch (_) {
+        }
+    }
+    try {
+        Object.defineProperty(CustomError, 'name', {
+            value: name,
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    catch (_) {
+    }
+    return CustomError;
+}
+
+var NotSupportedError = createCustomError('NotSupportedError');
+
+var PermissionType;
+(function (PermissionType) {
+    PermissionType["Notification"] = "notifications";
+    PermissionType["Geolocation"] = "geolocation";
+    PermissionType["Camera"] = "camera";
+    PermissionType["Microphone"] = "microphone";
+    PermissionType["MIDI"] = "midi";
+})(PermissionType || (PermissionType = {}));
+var PermissionState;
+(function (PermissionState) {
+    PermissionState["Grant"] = "grant";
+    PermissionState["Denied"] = "denied";
+    PermissionState["Prompt"] = "prompt";
+    PermissionState["Unsupported"] = "unsupported";
+})(PermissionState || (PermissionState = {}));
+var GET_USER_MEDIA = (function () {
+    if (typeof globalThis.navigator.mediaDevices !== 'undefined' && typeof globalThis.navigator.mediaDevices.getUserMedia !== 'undefined')
+        return globalThis.navigator.mediaDevices.getUserMedia.bind(globalThis.navigator.mediaDevices);
+    var legacy = (function () {
+        if (typeof globalThis.navigator.getUserMedia !== 'undefined')
+            return globalThis.navigator.getUserMedia;
+        if (typeof globalThis.navigator.webkitGetUserMedia !== 'undefined')
+            return globalThis.navigator.webkitGetUserMedia;
+        if (typeof globalThis.navigator.mozGetUserMedia !== 'undefined')
+            return globalThis.navigator.mozGetUserMedia;
+        if (typeof globalThis.navigator.msGetUserMedia !== 'undefined')
+            return globalThis.navigator.msGetUserMedia;
+    })();
+    if (typeof legacy !== 'undefined') {
+        return function legacyUserMedia(constraints) {
+            if (constraints === void 0) { constraints = {}; }
+            return new Promise(function (resolve, reject) {
+                legacy.call(globalThis.navigator, constraints, resolve, reject);
+            });
+        };
+    }
+})();
+
+var Permission = {
+    request: request,
+    check: check,
+    Constants: {
+        PermissionType: PermissionType,
+        PermissionState: PermissionState,
+    },
+    Errors: {},
+};
+function request(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.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');
+
+var Notification = {
+    send: send,
+    get supported() {
+        return supported();
+    },
+    Constants: {},
+    Errors: {
+        NotSupportedError: NotSupportedError,
+        PermissionNotGrantedError: PermissionNotGrantedError,
+    },
+};
+function send(options) {
+    return new Promise(function (resolve, reject) {
+        if (!supported())
+            return reject(new NotSupportedError('\'window.Notification\' does not supported.'));
+        Permission
+            .request(PermissionType.Notification)
+            .then(function (state) {
+            if (state === PermissionState.Grant) {
+                var constructorOptions = {
+                    badge: options.badge,
+                    body: options.body,
+                    data: options.data,
+                    dir: options.dir,
+                    icon: options.icon,
+                    lang: options.lang,
+                    requireInteraction: options.requireInteraction,
+                    silent: options.silent,
+                    tag: options.tag,
+                };
+                var notification = new globalThis.Notification(options.title, constructorOptions);
+                if (typeof options.onClick !== 'undefined')
+                    notification.onclick = options.onClick;
+                if (typeof options.onShow !== 'undefined')
+                    notification.onshow = options.onShow;
+                if (typeof options.onClose !== 'undefined')
+                    notification.onclose = options.onClose;
+                if (typeof options.onError !== 'undefined')
+                    notification.onerror = options.onError;
+                resolve(notification);
+            }
+            else {
+                reject(new PermissionNotGrantedError('\'notification\' permission is not granted.'));
+            }
+        });
+    });
+}
+function supported() {
+    return typeof globalThis.Notification !== 'undefined';
+}
+
+export { Notification as default };

package/dist/plugin/notification/src/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const FALLBACK_MEDIA_QUERY_LIST: MediaQueryList;

package/dist/plugin/notification/src/errors/not-supported-error.d.ts

@@ -0,0 +1,2 @@
+declare const NotSupportedError: ErrorConstructor;
+export { NotSupportedError, };

package/dist/plugin/notification/src/errors/permission-not-granted-error.d.ts

@@ -0,0 +1,2 @@
+declare const PermissionNotGrantedError: ErrorConstructor;
+export { PermissionNotGrantedError, };

package/dist/plugin/notification/src/plugin/appearance/constants/index.d.ts

@@ -0,0 +1,8 @@
+export declare enum Appearances {
+    Unknown = "unknown",
+    Light = "light",
+    Dark = "dark"
+}
+export declare let MEDIA_QUERY_LIST: MediaQueryList;
+export declare const CONTEXT: CanvasRenderingContext2D | null;
+export declare const SVG_PIXEL_DATA_URL: string;

package/dist/plugin/notification/src/plugin/appearance/cores/index.d.ts

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

package/dist/plugin/notification/src/plugin/appearance/index.d.ts

@@ -0,0 +1,4 @@
+import Appearance from "./cores";
+export * from "./types";
+export * from "./constants";
+export default Appearance;

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

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

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

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

package/dist/plugin/notification/src/plugin/badge/cores/index.d.ts

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

package/dist/plugin/notification/src/plugin/badge/index.d.ts

@@ -0,0 +1,3 @@
+import Badge from "./cores";
+export * from "./types";
+export default Badge;

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

@@ -0,0 +1,10 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface BadgeInstance {
+    set(contents: number): Promise<void>;
+    clear(): Promise<void>;
+    get supported(): boolean;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

package/dist/plugin/notification/src/plugin/badge/types/index.d.ts

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

package/dist/plugin/notification/src/plugin/battery/cores/index.d.ts

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

package/dist/plugin/notification/src/plugin/battery/index.d.ts

@@ -0,0 +1,3 @@
+import Badge from "./cores";
+export * from "./types";
+export default Badge;

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

@@ -0,0 +1,26 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+declare global {
+    interface Navigator {
+        getBattery(): Promise<BatteryManager>;
+    }
+}
+export interface BatteryManager extends EventTarget {
+    readonly charging: boolean;
+    readonly chargingTime: number;
+    readonly dischargingTime: number;
+    readonly level: number;
+    onChange: ((this: BatteryManager, ev: Event) => any) | null;
+    onchargingchange: ((this: BatteryManager, ev: Event) => any) | null;
+    onchargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
+    ondischargingtimechange: ((this: BatteryManager, ev: Event) => any) | null;
+    onlevelchange: ((this: BatteryManager, ev: Event) => any) | null;
+}
+export declare interface BatteryInstance {
+    get value(): Promise<BatteryManager>;
+    get supported(): boolean;
+    onChange(listener: (battery: BatteryManager) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

package/dist/plugin/notification/src/plugin/battery/types/index.d.ts

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

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

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