native-fn 1.1.2 → 1.1.4

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { PermissionState, PermissionType } from "../constants";
+export declare interface PermissionInstance {
+    request(type: PermissionType): Promise<PermissionState>;
+    check(type: PermissionType): Promise<PermissionState>;
+    Constants: {
+        PermissionType: typeof PermissionType;
+        PermissionState: typeof PermissionState;
+    };
+    Errors: {};
+}

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

@@ -0,0 +1,12 @@
+import { PipInstance } from "../types";
+declare global {
+    interface HTMLVideoElement {
+        webkitSupportsPresentationMode?: (mode: string) => boolean;
+        webkitSetPresentationMode?: (mode: string) => void;
+        webkitPresentationMode?: string;
+        onwebkitpresentationmodechanged?: ((this: HTMLVideoElement, ev: Event) => any) | null;
+        [key: symbol]: boolean | undefined;
+    }
+}
+declare const _default: PipInstance;
+export default _default;

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface PipInstance {
+    supported: boolean;
+    element: HTMLVideoElement | null;
+    isPip: boolean;
+    request(target?: HTMLVideoElement): Promise<void>;
+    exit(): Promise<void>;
+    toggle(target?: HTMLVideoElement): Promise<void>;
+    onChange(listener: (event: Event) => void, options?: AddEventListenerOptions): () => void;
+    onError(listener: (event: Event) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

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

@@ -0,0 +1,42 @@
+import { VersionResolver } from "../types";
+export declare enum OS {
+    Unknown = "Unknown",
+    Android = "Android",
+    iOS = "iOS",
+    Windows = "Windows",
+    MacOS = "MacOS"
+}
+export declare enum Devices {
+    Unknown = "Unknown",
+    Mobile = "Mobile",
+    Desktop = "Desktop"
+}
+export declare enum Engines {
+    Unknown = "Unknown",
+    EdgeHTML = "EdgeHTML",
+    ArkWeb = "ArkWeb",
+    Blink = "Blink",
+    Presto = "Presto",
+    WebKit = "WebKit",
+    Trident = "Trident",
+    NetFront = "NetFront",
+    KHTML = "KHTML",
+    Tasman = "Tasman",
+    Gecko = "Gecko"
+}
+export declare enum Browsers {
+    Unknown = "Unknown",
+    Chrome = "Chrome",
+    Safari = "Safari",
+    Edge = "Edge",
+    Firefox = "Firefox",
+    Opera = "Opera",
+    IE = "IE",
+    SamsungInternet = "SamsungInternet"
+}
+export declare const 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?][];
+export declare const ENGINE_RESOLVER_MAP: [RegExp, Engines, VersionResolver?][];
+export declare const BROWSER_RESOLVER_MAP: [RegExp, Browsers, VersionResolver?][];

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

@@ -0,0 +1,65 @@
+import { GPUAdapterInfo, PlatformInstance } from "../types";
+declare global {
+    interface Navigator {
+        userAgent?: string;
+        userAgentData?: UserAgentData;
+        language?: string;
+        languages?: readonly string[];
+        browserLanguage?: string;
+        systemLanguage?: string;
+        userLanguage?: string;
+        standalone?: boolean;
+        gpu?: WebGPU;
+    }
+    interface NodeProcessVersions {
+        node?: string;
+        chrome?: string;
+    }
+    interface NodeProcess {
+        versions?: NodeProcessVersions;
+        type?: string;
+        platform?: string;
+        getSystemVersion?(): string;
+    }
+    var process: NodeProcess | undefined;
+    namespace Intl {
+        const Locale: {
+            new (tag: string): IntlLocale;
+        };
+    }
+}
+interface IntlLocale {
+    getTextInfo?(): IntlLocaleTextInfo;
+    textInfo: IntlLocaleTextInfo;
+}
+interface IntlLocaleTextInfo {
+    direction: 'rtl' | 'ltr';
+}
+interface ModernUserAgentDataBrand {
+    brand: string;
+    version: string;
+}
+type UserAgentDataBrand = ModernUserAgentDataBrand | string | null | undefined;
+interface UserAgentDataValues {
+    brands?: UserAgentDataBrand[];
+    fullVersionList?: UserAgentDataBrand[];
+    platformVersion?: string | null | undefined;
+    platform?: string | null | undefined;
+    mobile?: boolean;
+}
+interface UserAgentData {
+    getHighEntropyValues?(hints: string[]): Promise<UserAgentDataValues>;
+}
+interface WebGPU {
+    requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | null>;
+}
+interface GPURequestAdapterOptions {
+    powerPreference?: GPUPowerPreference;
+    forceFallbackAdapter?: boolean;
+}
+type GPUPowerPreference = 'low-power' | 'high-performance';
+interface GPUAdapter {
+    readonly info: GPUAdapterInfo;
+}
+declare const Platform: PlatformInstance;
+export default Platform;

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

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

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

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

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

@@ -0,0 +1,42 @@
+import { Browsers, Devices, Engines, OS } from "../constants";
+import { Writeable } from "../../../types";
+export declare type VersionResolver = undefined | string | ((string: string | undefined) => string);
+export declare interface PlatformInstance {
+    get ready(): Promise<void>;
+    get userAgent(): string;
+    set userAgent(value: any);
+    get os(): NameVersionPair<OS>;
+    get engine(): NameVersionPair<Engines>;
+    get browser(): NameVersionPair<Browsers>;
+    get device(): Devices;
+    get locale(): Locale;
+    get gpu(): GPU;
+    get isNode(): boolean;
+    get isStandalone(): boolean;
+    get isWebview(): boolean;
+    Constants: {
+        OS: typeof OS;
+        Engines: typeof Engines;
+        Browsers: typeof Browsers;
+        Devices: typeof Devices;
+    };
+    Errors: {};
+}
+export declare interface NameVersionPair<T> {
+    name: T;
+    version: string;
+}
+export declare interface Locale {
+    language: string | null;
+    languages: string[];
+    timezone: string | null;
+    offset: number;
+    isRTL: boolean;
+}
+export interface GPUAdapterInfo {
+    readonly vendor?: string;
+    readonly architecture?: string;
+    readonly device?: string;
+    readonly description?: string;
+}
+export declare type GPU = Writeable<GPUAdapterInfo>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface VibrationInstance {
+    run(pattern: number | number[]): boolean;
+    stop(): boolean;
+    get supported(): boolean;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}

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

@@ -0,0 +1,35 @@
+export type EventTargetLike = EventTarget & {
+    attachEvent?(type: string, listener: (event: Event) => void): void;
+    detachEvent?(type: string, listener: (event: Event) => void): void;
+    webkitEnterFullscreen?(): void;
+    media?: string;
+    matches?: boolean | ((selectors: string) => boolean);
+    addListener?(callback: MediaQueryListCallback | null): void;
+    removeListener?(callback: MediaQueryListCallback | null): void;
+};
+export type MediaQueryListCallback = ((this: MediaQueryList, ev: MediaQueryListEvent) => any);
+export type AnyCallback = EventListenerOrEventListenerObject | MediaQueryListCallback;
+export declare interface EventListenerOptions<E extends Event = Event> {
+    type?: string;
+    callback: EventListenerOrEventListenerObject | MediaQueryListCallback | ((this: any, event: E) => void);
+    options?: AddEventListenerOptions | boolean;
+}
+export interface EventListenerInstance {
+    useStd: boolean;
+    add<E extends Event = Event>(target: EventTargetLike | undefined, eventListenerOptions: EventListenerOptions<E>): void;
+    remove<E extends Event = Event>(target: EventTargetLike | undefined, eventListenerOptions: EventListenerOptions<E>): void;
+}
+export type IEWrapper = (event: Event) => void;
+export type IEWrapperRecord = {
+    target: EventTarget;
+    type: string;
+    callback: AnyCallback;
+    wrapper: IEWrapper;
+};
+export type MediaQueryListWrapper = (this: MediaQueryList, ev: MediaQueryListEvent) => void;
+export type MediaQueryListWrapperRecord = {
+    target: MediaQueryList;
+    type: string;
+    callback: AnyCallback;
+    wrapper: MediaQueryListWrapper;
+};

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

@@ -0,0 +1,4 @@
+export * from "./native";
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};

package/dist/plugin/theme/src/types/listener-entry.d.ts

@@ -0,0 +1,5 @@
+export declare interface ListenerEntry<T> {
+    fn: (appearance: T) => any;
+    once: boolean;
+    signal?: AbortSignal;
+}

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

@@ -0,0 +1,31 @@
+import AppearanceInstance from "../plugin/appearance";
+import BadgeInstance from "../plugin/badge";
+import BatteryInstance from "../plugin/battery";
+import ClipboardInstance from "../plugin/clipboard";
+import DimensionInstance from "../plugin/dimension";
+import FullscreenInstance from "../plugin/fullscreen";
+import GeoLocationInstance from "../plugin/geolocation";
+import NotificationInstance from "../plugin/notification";
+import OpenInstance from "../plugin/open";
+import PlatformInstance from "../plugin/platform";
+import ThemeInstance from "../plugin/theme";
+import VibrationInstance from "../plugin/vibration";
+import PermissionInstance from "../plugin/permission";
+import PipInstance from "../plugin/pip";
+export declare interface NativeInstance {
+    version: string;
+    appearance: typeof AppearanceInstance;
+    badge: typeof BadgeInstance;
+    battery: typeof BatteryInstance;
+    clipboard: typeof ClipboardInstance;
+    dimension: typeof DimensionInstance;
+    fullscreen: typeof FullscreenInstance;
+    geolocation: typeof GeoLocationInstance;
+    notification: typeof NotificationInstance;
+    open: typeof OpenInstance;
+    permission: typeof PermissionInstance;
+    platform: typeof PlatformInstance;
+    pip: typeof PipInstance;
+    theme: typeof ThemeInstance;
+    vibration: typeof VibrationInstance;
+}

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/plugin/theme/src/utils/defer.d.ts

@@ -0,0 +1 @@
+export default function defer(task: () => void): void;

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

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

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

@@ -0,0 +1,3 @@
+import { EventListenerInstance } from "../types/event-listener";
+declare const EventListener: EventListenerInstance;
+export default EventListener;

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

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

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

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

package/dist/plugin/theme/src/utils/keys.d.ts

@@ -0,0 +1 @@
+export default function keys(object: object): string[];

package/dist/plugin/theme/src/utils/now.d.ts

@@ -0,0 +1 @@
+export default function now(): number;

package/dist/plugin/theme/src/utils/pad-start.d.ts

@@ -0,0 +1 @@
+export default function padStart(string: any, length: number, pad: string): any;

package/dist/plugin/theme/src/utils/random-string.d.ts

@@ -0,0 +1 @@
+export default function randomString(length: number): string;

package/dist/plugin/theme/src/utils/request.d.ts

@@ -0,0 +1,6 @@
+export interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: string | FormData | Blob;
+}
+export declare function request<T>(url: string, options?: RequestOptions): Promise<T | undefined>;

package/dist/plugin/theme/src/utils/set-style.d.ts

@@ -0,0 +1,3 @@
+export default function setStyle(element: HTMLElement, styles: {
+    [K in keyof CSSStyleDeclaration]?: string;
+}): void;

package/dist/plugin/vibration/index.cjs

@@ -0,0 +1,110 @@
+'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 Vibration = {
+    run: run,
+    stop: stop,
+    get supported() {
+        return supported();
+    },
+    Constants: {},
+    Errors: {
+        NotSupportedError: NotSupportedError,
+    },
+};
+function run(pattern) {
+    if (supported())
+        return globalThis.navigator.vibrate(pattern);
+    throw new NotSupportedError('\'navigator.vibrate\' does not supported.');
+}
+function stop() {
+    return this.run(0);
+}
+function supported() {
+    return typeof globalThis.navigator.vibrate !== 'undefined';
+}
+
+module.exports = Vibration;

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

@@ -0,0 +1,16 @@
+declare const NotSupportedError: ErrorConstructor;
+
+declare interface VibrationInstance {
+    run(pattern: number | number[]): boolean;
+    stop(): boolean;
+    get supported(): boolean;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
+}
+
+declare const Vibration: VibrationInstance;
+
+export { Vibration as default };
+export type { VibrationInstance };