native-fn 1.0.90 → 1.1.1

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

@@ -1,12 +1,15 @@
-export declare interface Fullscreen {
-    enabled: boolean;
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface FullscreenInstance {
+    supported: boolean;
     element: Element | null;
     isFullscreen: boolean;
     request(target?: Element, options?: FullscreenOptions): Promise<void>;
     exit(): Promise<void>;
     toggle(target?: Element, options?: FullscreenOptions): Promise<void>;
-    onchange(handler: (event: Event) => void): () => void;
-    onerror(handler: (event: Event) => void): () => void;
+    onChange(listener: (event: Event) => void, options?: AddEventListenerOptions): () => void;
+    onError(listener: (event: Event) => void, options?: AddEventListenerOptions): () => void;
     Constants: {};
-    Errors: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+    };
 }

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+import { PermissionNotGrantedError } from "../../../errors/permission-not-granted-error";
+export declare interface GeolocationInstance {
+    get value(): Promise<GeolocationCoordinates>;
+    get supported(): boolean;
+    onChange(listener: (coordinates: GeolocationCoordinates) => void, options?: AddEventListenerOptions): () => void;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { NotSupportedError } from "../../../errors/not-supported-error";
+import { PermissionNotGrantedError } from "../../../errors/permission-not-granted-error";
+export 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, ev: Event) => any);
+    onClose?: ((this: Notification, ev: Event) => any);
+    onError?: ((this: Notification, ev: Event) => any);
+    onShow?: ((this: Notification, ev: Event) => any);
+}
+export declare interface NotificationInstance {
+    send(options: NotificationOptions): Promise<Notification>;
+    get supported(): boolean;
+    Constants: {};
+    Errors: {
+        NotSupportedError: typeof NotSupportedError;
+        PermissionNotGrantedError: typeof PermissionNotGrantedError;
+    };
+}

package/dist/{plugin/appearance/src/plugin/app → src/plugin/open}/constants/index.d.ts

@@ -5,11 +5,6 @@ export declare enum AppOpenState {
     Fallback = 3,
     Store = 4
 }
-export declare enum MessengerType {
-    Telephone = "telephone",
-    Message = "message",
-    Mail = "mail"
-}
 export declare enum SettingType {
     General = "general",
     Network = "network",
@@ -22,4 +17,24 @@ export declare enum SettingType {
     Accounts = "accounts",
     Storage = "storage"
 }
+export declare enum CameraType {
+    Image = "image",
+    Video = "video"
+}
+export declare enum CaptureType {
+    User = "user",
+    Environment = "environment"
+}
+export declare enum ExplorerStartIn {
+    Desktop = "desktop",
+    Documents = "documents",
+    Downloads = "downloads",
+    Music = "music",
+    Pictures = "pictures",
+    Videos = "videos"
+}
+export declare enum DirectoryExploreMode {
+    Read = "read",
+    ReadWrite = "readwrite"
+}
 export declare const SETTING_URL: Record<'Android' | 'Windows' | 'MacOS' | 'MacOS13+', Record<SettingType, string>>;

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

@@ -0,0 +1,55 @@
+import { Contact, OpenInstance } from "../types";
+declare global {
+    interface Document {
+        webkitVisibilityState?: 'hidden' | 'visible';
+        mozVisibilityState?: 'hidden' | 'visible';
+        msVisibilityState?: 'hidden' | 'visible';
+        webkitHidden?: boolean;
+        mozHidden?: boolean;
+        msHidden?: boolean;
+    }
+    interface Navigator {
+        contacts?: ContactsManager;
+    }
+    interface FileSystemDirectoryHandle {
+        entries(): AsyncIterator<[string, FileSystemHandle]>;
+    }
+    var showOpenFilePicker: (options?: OpenFilePickerOptions) => Promise<FileSystemFileHandle[]>;
+    var showDirectoryPicker: (options?: OpenDirectoryPickerOptions) => Promise<FileSystemDirectoryHandle>;
+    var cordova: object | undefined;
+}
+interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return?(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
+}
+type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+interface IteratorYieldResult<TYield> {
+    done?: false;
+    value: TYield;
+}
+interface IteratorReturnResult<TReturn> {
+    done: true;
+    value: TReturn;
+}
+interface OpenFilePickerOptions {
+    excludeAcceptAllOption?: boolean;
+    id?: string;
+    multiple?: boolean;
+    startIn?: 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos';
+    types?: {
+        description?: string;
+        accept: Record<string, string[]>;
+    }[];
+}
+interface OpenDirectoryPickerOptions {
+    id?: string;
+    mode?: 'read' | 'readwrite';
+    startIn?: 'desktop' | 'documents' | 'downloads' | 'music' | 'pictures' | 'videos';
+}
+interface ContactsManager {
+    select(properties: string[], options?: Record<string, any>): Promise<Contact[]>;
+    getProperties(): Promise<string[]>;
+}
+declare const Open: OpenInstance;
+export default Open;

package/dist/src/plugin/open/errors/user-cancel-error.d.ts

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

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

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

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

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

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

@@ -0,0 +1,187 @@
+import { AppOpenState, CameraType, CaptureType, DirectoryExploreMode, ExplorerStartIn, SettingType } from "../constants";
+import { OS } from "../../platform/constants";
+import { URLOpenError } from "../errors/url-open-error";
+import { UserCancelledError } from "../errors/user-cancel-error";
+import { NotSupportedError } from "../../../errors/not-supported-error";
+export declare interface AppInfo {
+    scheme?: URLCandidate;
+    fallback?: URLCandidateOrFallback;
+    timeout?: number;
+    allowAppStore?: boolean;
+    allowWebStore?: boolean;
+}
+export declare interface PackageName {
+    packageName?: string;
+}
+export declare interface ProductId {
+    productId?: string;
+}
+export declare interface BundleId {
+    bundleId?: string;
+}
+export declare interface TrackId {
+    trackId?: string;
+}
+export declare interface AndroidAppInfo extends AppInfo, PackageName {
+    intent?: URLCandidate;
+}
+export declare interface IOSAppInfo extends AppInfo, BundleId, TrackId {
+    universal?: URLCandidate;
+}
+export declare interface WindowsAppInfo extends AppInfo, PackageName, ProductId {
+}
+export declare interface MacOSAppInfo extends AppInfo, BundleId, TrackId {
+}
+export declare interface StoreInfo {
+    appStore?: string;
+    webStore?: string;
+}
+export declare interface AppOpenOptions {
+    [OS.Android]?: AndroidAppInfo;
+    ['android']?: AndroidAppInfo;
+    [OS.iOS]?: IOSAppInfo;
+    ['ios']?: IOSAppInfo;
+    [OS.Windows]?: WindowsAppInfo;
+    ['windows']?: WindowsAppInfo;
+    [OS.MacOS]?: MacOSAppInfo;
+    ['macos']?: MacOSAppInfo;
+}
+export interface Contact {
+    name?: string;
+    email?: string;
+    tel?: string;
+    address?: string;
+    icon?: Blob[];
+}
+export interface ContactOptions {
+    multiple?: boolean;
+}
+export type FileExtension = `.${string}`;
+export type FileMimeType = `${string}/${string}`;
+export interface FileOptions {
+    multiple?: boolean;
+    accept?: (FileExtension | FileMimeType)[];
+    id?: string;
+    startIn?: ExplorerStartIn;
+}
+export interface DirectoryOptions {
+    mode?: DirectoryExploreMode;
+    id?: string;
+    startIn?: ExplorerStartIn;
+}
+export interface FileWithPath {
+    file: File;
+    relativePath: string;
+}
+export interface CameraOptions {
+    type?: CameraType;
+    capture?: CaptureType;
+}
+export interface CalendarOptions {
+    title?: string;
+    description?: string;
+    location?: string;
+    allDay?: boolean;
+    startDate: Date;
+    endDate: Date;
+    alarm?: CalendarAlarmOptions[];
+    recur?: CalendarRecurOptions;
+}
+export type CalendarAlarmOptions = {
+    description?: string;
+} & CalendarAlarmTrigger;
+export type CalendarAlarmTrigger = {
+    datetime?: Date;
+    repeat?: never;
+    repeatDuration?: never;
+    before?: never;
+    weeks?: never;
+    days?: never;
+    hours?: never;
+    minutes?: never;
+    seconds?: never;
+} | {
+    datetime?: never;
+    repeat?: number;
+    repeatDuration?: number;
+    before?: boolean;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+};
+export type CalendarRecurWeekDay = 'MO' | 'TU' | 'WE' | 'TH' | 'FR' | 'SA' | 'SU';
+export type CalendarRecurDayValue = CalendarRecurWeekDay | `${number}${CalendarRecurWeekDay}`;
+export type CalendarRecurOptions = {
+    frequency: 'SECONDLY' | 'MINUTELY' | 'HOURLY' | 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'YEARLY';
+    interval?: number;
+    byMonth?: number[];
+    byWeekNo?: number[];
+    byYearDay?: number[];
+    byMonthDay?: number[];
+    byDay?: CalendarRecurDayValue[];
+    byHour?: number[];
+    byMinute?: number[];
+    bySecond?: number[];
+    bySetPos?: number[];
+    weekStart?: CalendarRecurWeekDay;
+} & CalendarRecurLimit;
+export type CalendarRecurLimit = {
+    count: number;
+    until?: never;
+} | {
+    count?: never;
+    until: Date;
+} | {
+    count?: never;
+    until?: never;
+};
+export declare type URLCandidate = URL | string;
+export declare type URLCandidateOrFallback = URLCandidate | (() => any);
+export declare type URLStringOrFallback = string | (() => any);
+export declare interface TelephoneOptions {
+    to?: string | string[];
+}
+export declare interface MessageOptions extends TelephoneOptions {
+    body?: string;
+}
+export declare interface MailOptions extends MessageOptions {
+    cc?: string | string[];
+    bcc?: string | string[];
+    subject?: string;
+}
+export declare interface OpenInstance {
+    app(options: AppOpenOptions): Promise<AppOpenState>;
+    telephone(options: TelephoneOptions): Promise<void>;
+    message(options: MessageOptions): Promise<void>;
+    mail(options: MailOptions): Promise<void>;
+    file(options?: FileOptions): Promise<File[]>;
+    directory(options?: DirectoryOptions): Promise<FileWithPath[]>;
+    setting(type: SettingType): Promise<void>;
+    camera(options?: CameraOptions): Promise<File[]>;
+    contact(options?: ContactOptions): Promise<Contact[]>;
+    share(options: ShareData): Promise<void>;
+    calendar(options: CalendarOptions): void;
+    supported: {
+        get intent(): boolean;
+        get universal(): boolean;
+        get setting(): boolean;
+        get directory(): boolean;
+        get camera(): boolean;
+        get contact(): boolean;
+        get share(): boolean;
+        get calendar(): boolean;
+    };
+    Constants: {
+        AppOpenState: typeof AppOpenState;
+        SettingType: typeof SettingType;
+        CameraType: typeof CameraType;
+        CaptureType: typeof CaptureType;
+    };
+    Errors: {
+        URLOpenError: typeof URLOpenError;
+        NotSupportedError: typeof NotSupportedError;
+        UserCancelledError: typeof UserCancelledError;
+    };
+}

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

@@ -0,0 +1,22 @@
+declare global {
+    interface Navigator {
+        getUserMedia?(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+        webkitGetUserMedia?(constraints: MediaStreamConstraints, successCallback: (stream: MediaStream) => void, errorCallback: (error: DOMException) => void): void;
+        mozGetUserMedia?(constraints: MediaStreamConstraints, successCallback: (stream: MediaStream) => void, errorCallback: (error: DOMException) => void): void;
+        msGetUserMedia?(constraints: MediaStreamConstraints, successCallback: (stream: MediaStream) => void, errorCallback: (error: DOMException) => void): void;
+    }
+}
+export declare enum PermissionType {
+    Notification = "notifications",
+    Geolocation = "geolocation",
+    Camera = "camera",
+    Microphone = "microphone",
+    MIDI = "midi"
+}
+export declare enum PermissionState {
+    Grant = "grant",
+    Denied = "denied",
+    Prompt = "prompt",
+    Unsupported = "unsupported"
+}
+export declare const GET_USER_MEDIA: ((constraints?: MediaStreamConstraints) => Promise<MediaStream>) | undefined;

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

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

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

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

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

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

package/dist/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/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/src/plugin/pip/index.d.ts

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

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

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

package/dist/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/src/plugin/platform/constants/index.d.ts

@@ -40,4 +40,3 @@ 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?][];
-export declare const BOT_REGEXP: RegExp[];

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

@@ -1,4 +1,4 @@
-import { Platform } from "../types";
+import { GPUAdapterInfo, PlatformInstance } from "../types";
 declare global {
     interface Navigator {
         userAgent?: string;
@@ -8,6 +8,8 @@ declare global {
         browserLanguage?: string;
         systemLanguage?: string;
         userLanguage?: string;
+        standalone?: boolean;
+        gpu?: WebGPU;
     }
     interface NodeProcessVersions {
         node?: string;
@@ -48,5 +50,16 @@ interface UserAgentDataValues {
 interface UserAgentData {
     getHighEntropyValues?(hints: string[]): Promise<UserAgentDataValues>;
 }
-declare const Platform: Platform;
+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/src/plugin/platform/types/platform.d.ts

@@ -1,6 +1,8 @@
 import { Browsers, Devices, Engines, OS } from "../constants";
+import { Writeable } from "../../../types";
 export declare type VersionResolver = undefined | string | ((string: string | undefined) => string);
-export declare interface Platform {
+export declare interface PlatformInstance {
+    get ready(): Promise<void>;
     get userAgent(): string;
     set userAgent(value: any);
     get os(): NameVersionPair<OS>;
@@ -8,11 +10,10 @@ export declare interface Platform {
     get browser(): NameVersionPair<Browsers>;
     get device(): Devices;
     get locale(): Locale;
-    get renderer(): string;
+    get gpu(): GPU;
     get isNode(): boolean;
     get isStandalone(): boolean;
     get isWebview(): boolean;
-    get isBot(): boolean;
     Constants: {
         OS: typeof OS;
         Engines: typeof Engines;
@@ -32,3 +33,10 @@ export declare interface Locale {
     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/src/plugin/theme/cores/index.d.ts

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

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

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

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

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

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

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

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

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

package/dist/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/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/src/types/index.d.ts

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

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

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