starti.app 2.0.3 → 2.0.16

package/dist/EventTarget.d.ts

@@ -0,0 +1,17 @@
+type EventListenerOrEventListenerObjectWithType<T> = EventListenerWithType<T> | EventListenerObjectWithType<T>;
+interface EventListenerWithType<T> {
+    (evt: T): void;
+}
+interface EventListenerObjectWithType<T> {
+    handleEvent(evt: T): void;
+}
+declare class EventTarget {
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    protected dispatchEvent(event: Event): boolean;
+}
+export declare class EventTargetWithType<T extends Record<string | number | symbol, Event>> extends EventTarget {
+    addEventListener<K extends keyof T>(type: K, callback: EventListenerOrEventListenerObjectWithType<T[K]>, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof T>(type: K, callback: EventListenerOrEventListenerObjectWithType<T[K]>, options?: boolean | EventListenerOptions): void;
+}
+export {};

package/dist/getIntegrations.d.ts

@@ -0,0 +1,2 @@
+import { Integrations } from "./integrations";
+export declare function getIntegration<T extends keyof Integrations>(integration: T): Integrations[T];

package/dist/index.d.ts

@@ -1,39 +1,10 @@
-import { InitializeParams } from "./@types/types";
-declare const startiappModuleEvents: readonly ["app-integrations-are-ready"];
-declare type StartiappEvents = "ready" | "error" | typeof startiappModuleEvents[number];
-declare class StartiappClass extends EventTarget {
-    get appIntegration(): import("./@types/integrations").AppIntegration;
-    /** Basic calls to the app. */
-    App: import("./app").IApp;
-    /** Access to device functionality. */
-    Device: import("./integrations/device").IDevice;
-    /** The biometric functionality. */
-    Biometrics: import("./integrations/biometrics").IBiometrics;
-    /** Access to client user functionality. */
-    User: import("./clientUser").IClientUser;
-    /** The NFC scanning functionality. */
-    NfcScanner: import("./integrations/nfc").INFC;
-    /** Access to push notifications using Firebase. */
-    PushNotification: import("./integrations/pushnotification").IPushNotification;
-    /** The QR- and barcode scanning functionality. */
-    QrScanner: import("./integrations/qrscanner").IQrScanner;
-    /** The share functionality. */
-    Share: import("./integrations/share").IShare;
-    /** The network functionality. */
-    Network: import("./integrations/network").INetwork;
-    /** The storage functionality. */
-    Storage: import("./integrations/storage").IStorage;
-    /** Trigger functionality */
-    Trigger: import("./integrations/trigger").ITrigger;
-    /** The In App Purchases functionality */
-    Iap: import("./integrations/iap").IIap;
-    Developer: import("./integrations/developer").IDeveloper;
-    /** Call this method to initialize the starti.app API integration. This method should be called AFTER all integrations are ready (see onIntegrationsAreReady). */
-    initialize(options?: InitializeParams): void;
-    /** Call this method to check if the app is running in the starti.app app. */
-    isRunningInApp(): boolean;
-    addEventListener(type: StartiappEvents, callback: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener(type: StartiappEvents, callback: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+import "./polyfills/eventTarget.js";
+import { StartiappClass } from "./startiapp";
+declare global {
+    const startiapp: StartiappClass;
+    interface Window {
+        startiapp: StartiappClass;
+    }
 }
-declare let startiapp: StartiappClass;
-export default startiapp;
+declare const _default: StartiappClass;
+export default _default;

package/dist/integrationWrapper.d.ts

@@ -0,0 +1,69 @@
+import { Integrations } from "./integrations";
+type FunctionOfIntegrationMethod<TIntegrationKey extends keyof Integrations, TIntegrationMethodKey extends keyof Integrations[TIntegrationKey]> = Integrations[TIntegrationKey][TIntegrationMethodKey] extends (...args: infer TArgs) => infer TReturn ? (...args: TArgs) => TReturn : never;
+type MethodFunction = (...args: any) => any;
+type PromiseResolve<T> = (value?: T | PromiseLike<T>) => void;
+type AsyncIntegrationResolverCallOptions<TMethodKey, TMethodResponse> = {
+    methodName: TMethodKey;
+    shouldResolve?: (value: TMethodResponse) => boolean;
+};
+declare class AsyncIntegrationResolver<TIntegrationKey extends keyof Integrations> {
+    private integrationKey;
+    promises: Record<string, Array<{
+        resolve: PromiseResolve<any>;
+        shouldResolve?: (value: any) => boolean;
+    }>>;
+    events: Record<string, Array<(...args: any[]) => void>>;
+    private get integration();
+    constructor(integrationKey: TIntegrationKey);
+    /**
+     * Asynchronously calls a method on the integration, handling its execution and promise resolution.
+     *
+     * @param methodName The name of the method to call on the integration.
+     * @param args The arguments to pass to the method.
+     *
+     * @example
+     * ```typescript
+     * const result: Promise<MethodNameResult> = await <integration>.call("methodName", ...args);
+     * ```
+     */
+    call<TIntegrationMethodKey extends keyof Integrations[TIntegrationKey], TMethod extends MethodFunction = FunctionOfIntegrationMethod<TIntegrationKey, TIntegrationMethodKey>, TMethodReturnType = ReturnType<TMethod>>(optionsOrMethodName: AsyncIntegrationResolverCallOptions<TIntegrationMethodKey, TMethodReturnType> | TIntegrationMethodKey, ...args: Parameters<TMethod>): Promise<TMethodReturnType>;
+    /**
+     * Registers an event listener for a specified event name.
+     *
+     * @param eventName The name of the event to listen for. Should match the name emitted by the app.
+     * @param listener The function to call when the event is emitted.
+     *
+     * @example
+     * ```typescript
+     * <integration>.listen("eventName", (args) => {
+     *    console.log(args);
+     * });
+     * ```
+     */
+    listen(eventName: string, listener: (...args: any[]) => void): Promise<void>;
+    private callIntegration;
+}
+/**
+ * Creates a wrapper around an integration, allowing for asynchronous method calls and event listening.
+ *
+ * @param integration The name of the integration to wrap
+ * @param overrideResolverName The name of the window object to register the integration on. Defaults to `startiapp${integration.replace("Integration", "")}`
+ *
+ * @example
+ * ```typescript
+ *
+ * // Create a wrapper around the AppIntegration and register it on the window object
+ * // This allows the app to call methods on the integration and listen for events
+ * const appIntegration = createIntegrationWrapper("AppIntegration");
+ *
+ * // Call a method on the integration
+ * const brandId = await appIntegration.call("brandId");
+ *
+ * // Listen for an event emitted by the integration
+ * appIntegration.listen("navigatingPage", (args) => {
+ *   console.log(args);
+ * });
+ * ```
+ */
+export declare function createIntegrationWrapper<TIntegrationKey extends keyof Integrations>(integration: TIntegrationKey, overrideResolverName?: string): AsyncIntegrationResolver<TIntegrationKey>;
+export {};

package/dist/integrations/App/AppIntegration.d.ts

@@ -0,0 +1,114 @@
+import { EventTargetWithType } from "../../EventTarget";
+import { SetStatusBarOptions, SpinnerOptions, Startiapp } from "../../startiapp";
+import { NavigatingPageEvent } from "./typings";
+export declare class App extends EventTargetWithType<{
+    navigatingPage: CustomEvent<NavigatingPageEvent>;
+    appInForeground: CustomEvent<void>;
+}> {
+    private readonly startiapp;
+    private appIntegration;
+    private alternateIconsIntegration;
+    private hasStartiappLoaded;
+    constructor(startiapp: Startiapp);
+    isStartiappLoaded(): boolean;
+    /**
+     * Get the brand id of the app.
+     *
+     * @example
+     * ```typescript
+     * // "example-brand"
+     * const brandId = await startiapp.App.brandId();
+     * ```
+     */
+    brandId: () => Promise<string>;
+    /**
+     * Get the device id of the app.
+     *
+     * @example
+     * ```typescript
+     * // "00000000-0000-0000-0000-000000000000"
+     * const deviceId = await startiapp.App.deviceId();
+     * ```
+     */
+    deviceId: () => Promise<string>;
+    /**
+     * Get the version of the app.
+     *
+     * @example
+     * ```typescript
+     * // "1.0.0"
+     * const version = await startiapp.App.version();
+     * ```
+     */
+    version: () => Promise<string>;
+    /**
+     * Add an internal domain to the app.
+     *
+     * @example
+     * ```typescript
+     * await startiapp.App.addInternalDomain("example.com");
+     * ```
+     */
+    addInternalDomain: (domain: string) => Promise<void>;
+    /**
+     * Remove an internal domain from the app.
+     *
+     * @example
+     * ```typescript
+     * await startiapp.App.removeInternalDomain("example.com");
+     * ```
+     */
+    removeInternalDomain: (domain: string) => Promise<void>;
+    /** Sets the status bar options for the app. */
+    setStatusBar: (options: SetStatusBarOptions) => Promise<void>;
+    /** Sets the navigation spinner options for the app. */
+    setSpinner: (options: SpinnerOptions) => Promise<void>;
+    /** Enables the screen to rotate */
+    enableScreenRotation: () => Promise<void>;
+    /** Prevents the screen from rotation */
+    disableScreenRotation: () => Promise<void>;
+    /** Enables swipe gestures for navigation */
+    enableSwipeNavigation: () => Promise<void>;
+    /** Disables swipe gestures for navigation */
+    disableSwipeNavigation: () => Promise<void>;
+    /**
+     * Set the app icon.
+     *
+     * @example
+     * ```typescript
+     * await startiapp.App.setAppIcon("icon-name");
+     * ```
+     */
+    setAppIcon: (iconName: string) => Promise<void>;
+    /**
+     * Get the current app icon.
+     *
+     * @example
+     * ```typescript
+     * const currentIcon = await startiapp.App.getCurrentIcon();
+     * console.log(currentIcon);
+     */
+    getCurrentIcon: () => Promise<string>;
+    /**
+     * Get the available app icons.
+     *
+     * @example
+     * ```typescript
+     * const availableIcons = await startiapp.App.getAvailableIcons();
+     * console.log(availableIcons);
+     * ```
+     */
+    getAvailableIcons: () => Promise<string[]>;
+    /**
+     * Prompt the user to review the app.
+     *
+     * @example
+     * ```typescript
+     * await startiapp.App.requestReview();
+     * ```
+     */
+    requestReview: () => Promise<void>;
+    private onStartiappReady;
+    private handleNavigatingPageEvent;
+    private handleAppInForegroundEvent;
+}

package/dist/integrations/App/typings.d.ts

@@ -0,0 +1,14 @@
+export interface NavigatingPageEvent {
+    url: string;
+    opensExternalbrowser: boolean;
+}
+export interface NavigationSpinnerOptions {
+    show: boolean;
+    color: string;
+    delay: number;
+    excludedDomains: string[];
+}
+export interface RegexDto {
+    pattern: string;
+    flags: string;
+}

package/dist/integrations/Biometrics/BiometricsIntegration.d.ts

@@ -0,0 +1,69 @@
+import { Startiapp } from "../../startiapp";
+export declare class Biometrics extends EventTarget {
+    private readonly startiapp;
+    private biometricsIntegration;
+    private SECURED_CONTENT_KEY;
+    private SECURED_LOGIN_KEY;
+    private defaultScanTitle;
+    private defaultScanReason;
+    constructor(startiapp: Startiapp);
+    /**
+     * Starts a biometrics scan
+     *
+     * @param title - The title of the scan.
+     * @param reason - The reason for the scan.
+     * @returns A boolean indicating if the scan was successful.
+     */
+    scan(title?: string, reason?: string): Promise<boolean>;
+    /**
+     * Retrieves the authentication type from the biometrics integration.
+     */
+    getAuthenticationType(): Promise<BiometricsAuthenticationType>;
+    /**
+     * Saves secured content.
+     */
+    setSecuredContent(content: unknown): Promise<void>;
+    /**
+     * Saves the username and password.
+     */
+    setUsernameAndPassword(username: string, password: string): Promise<void>;
+    /**
+     * Retrieves the saved username and password.
+     */
+    getUsernameAndPassword(title?: string, reason?: string): Promise<{
+        username: string;
+        password: string;
+    } | null>;
+    /**
+     * Checks if there's a saved username and password.
+     */
+    hasUsernameAndPassword(): Promise<BiometricsResultReponse<boolean>>;
+    /**
+     *  Removes the saved username and password.
+     */
+    removeUsernameAndPassword(): Promise<void>;
+    /**
+     * Retrieves secured content.
+     *
+     * @param title - The title of the secured content.
+     * @param reason - The reason for retrieving the secured content.
+     * @returns The secured content.
+     */
+    getSecuredContent<T>(title?: string, reason?: string): Promise<T | null>;
+    /**
+     * Checks if there's secured content.
+     * @returns Returns true if the secured content exists, false otherwise.
+     */
+    hasSecuredContent(): Promise<BiometricsResultReponse<boolean>>;
+    /**
+     * Removes secured content.
+     *
+     * @returns A promise that resolves when the secured content is successfully removed.
+     */
+    removeSecuredContent(): Promise<void>;
+}
+export type BiometricsAuthenticationType = "None" | "Face" | "Fingerprint";
+export type BiometricsResultReponse<T> = {
+    key: string;
+    result: T;
+};

package/dist/integrations/Developer/DeveloperIntegration.d.ts

@@ -0,0 +1,15 @@
+import { Startiapp } from "../../startiapp";
+export declare class Developer extends EventTarget {
+    private readonly startiapp;
+    private integration;
+    constructor(startiapp: Startiapp);
+    /**
+     * Intentionally crashes the app.
+     *
+     * @example
+     * ```typescript
+     * await startiapp.Developer.closeApp();
+     * ```
+     */
+    closeApp: () => Promise<void>;
+}

package/dist/integrations/Device/DeviceIntegration.d.ts

@@ -0,0 +1,28 @@
+import { EventTargetWithType } from "../../EventTarget";
+import { Startiapp } from "../../startiapp";
+export declare class Device extends EventTargetWithType<{
+    shake: CustomEvent<never>;
+}> {
+    private readonly startiapp;
+    private deviceIntegration;
+    constructor(startiapp: Startiapp);
+    /**
+     * Starts the accelerometer.
+     *
+     * @returns A promise that resolves when the accelerometer has started.
+     */
+    startAccelerometer(): Promise<void>;
+    /**
+     * Stops the accelerometer.
+     *
+     * @returns A promise that resolves when the accelerometer is stopped.
+     */
+    stopAccelerometer(): Promise<void>;
+    /**
+     * Checks if the accelerometer is started.
+     *
+     * @returns True if the accelerometer is started, false otherwise.
+     */
+    isAccelerometerStarted(): Promise<boolean>;
+    protected onShakeEvent(): void;
+}

package/dist/integrations/InAppPurchase/InAppPurchaseIntegration.d.ts

@@ -0,0 +1,39 @@
+import { Startiapp } from "../../startiapp";
+export declare class InAppPurchase extends EventTarget {
+    private readonly startiapp;
+    private inAppPurchaseIntegration;
+    constructor(startiapp: Startiapp);
+    /**
+     * Purchases a product.
+     *
+     * @param productId - The ID of the product to purchase.
+     * @param purchaseType - The type of purchase.
+     * @returns A promise that resolves when the purchase is completed.
+     */
+    purchaseProduct(productId: string, purchaseType: InApPurchasePurchaseType): Promise<InAppPurchaseResponse<InAppPurchaseProductResponse>>;
+    /**
+     * Retrieves the product with the specified ID and purchase type.
+     *
+     * @param productId - The ID of the product to retrieve.
+     * @param purchaseType - The type of purchase.
+     * @returns The retrieved product.
+     */
+    getProduct(productId: string, purchaseType: InApPurchasePurchaseType): Promise<InAppPurchaseResponse<InAppPurchaseGetProductResponse>>;
+}
+export type InAppPurchaseResponse<T extends InAppPurchaseProductResponse | InAppPurchaseGetProductResponse> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    errorMessage: string;
+};
+export type InAppPurchaseProductResponse = {
+    transactionIdentifier: string;
+};
+export type InAppPurchaseGetProductResponse = {
+    name: string;
+    description: string;
+    localizedPrice: string;
+    currencyCode: string;
+};
+export type InApPurchasePurchaseType = "nonconsumable" | "consumable";

package/dist/integrations/Location/LocationIntegration.d.ts

@@ -0,0 +1,6 @@
+import { Startiapp } from "../../startiapp";
+export declare class Location extends EventTarget {
+    private readonly startiapp;
+    private locationIntegration;
+    constructor(startiapp: Startiapp);
+}

package/dist/integrations/{network.d.ts → Network/NetworkIntegration.d.ts}

@@ -1,16 +1,12 @@
-import { EventTargetMethods } from "../@types/EventHandlerWithTypes";
-declare type ListenResponse = {
-    success: boolean;
-    message?: string;
-};
-declare type NetworkAccess = "ConstrainedInternet" | "Internet" | "Local" | "None" | "Unknown";
-export declare const Network: INetwork;
-declare type NetworkEvents = {
+import { EventTargetWithType } from "../../EventTarget";
+import { Startiapp } from "../../startiapp";
+export declare class Network extends EventTargetWithType<{
     connectionStateChanged: CustomEvent<ConnectionChangeEvent>;
     udpPacketReceived: CustomEvent<UdpPacketReceivedEvent>;
-};
-export interface INetwork extends EventTargetMethods<NetworkEvents> {
-    /** Returns the current SSID of the device. */
+}> {
+    private readonly startiapp;
+    private networkIntegration;
+    constructor(startiapp: Startiapp);
     /** Sends a UDP broadcast to the local network. */
     sendUdpBroadcast(port: number, message: string): Promise<boolean>;
     /** Returns the current connectivity state. */
@@ -23,5 +19,23 @@ export interface INetwork extends EventTargetMethods<NetworkEvents> {
     startListeningForConnectionChanges(): Promise<ListenResponse>;
     /** Stops listening for changes in the network connection. */
     stopListeningForConnectionChanges(): Promise<ListenResponse>;
+    private handleConnectionStateChanged;
+    private handleUdpPacketReceived;
 }
+export type NetworkAccess = "ConstrainedInternet" | "Internet" | "Local" | "None" | "Unknown";
+type ConnectionProfile = "Bluetooth" | "Cellular" | "Ethernet" | "WiFi" | "Unknown";
+type ConnectionChangeEvent = {
+    networkAccess: NetworkAccess;
+    connectionProfiles: ConnectionProfile;
+};
+type UdpPacketReceivedEvent = {
+    detail: {
+        message: string;
+        ip: string;
+    };
+};
+export type ListenResponse = {
+    success: boolean;
+    message?: string;
+};
 export {};

package/dist/integrations/NfcScanner/NfcScannerIntegration.d.ts

@@ -0,0 +1,39 @@
+import { EventTargetWithType } from "../../EventTarget";
+import { Startiapp } from "../../startiapp";
+export declare class NfcScanner extends EventTargetWithType<{
+    nfcTagScanned: CustomEvent<NfcTagResultRecieved>;
+}> {
+    private readonly startiapp;
+    private nfcIntegration;
+    constructor(startiapp: Startiapp);
+    /**
+     * Checks if NFC is supported.
+     * @returns True if NFC is supported, false otherwise.
+     */
+    isNfcSupported(): Promise<boolean>;
+    /**
+     * Checks if NFC is enabled.
+     *
+     * @returns A boolean indicating if NFC is enabled.
+     */
+    isNfcEnabled(): Promise<boolean>;
+    /**
+     * Starts the NFC scanner.
+     *
+     * @returns A promise that resolves when the NFC scanner starts listening.
+     */
+    startNfcScanner(): Promise<void>;
+    /**
+     * Stops the NFC scanner from listening for NFC events.
+     *
+     * @returns A promise that resolves when the NFC scanner has stopped listening.
+     */
+    stopNfcScanner(): Promise<void>;
+    private nfcTagScannedEvent;
+}
+type NfcTagResultRecieved = Array<{
+    mimeType: string;
+    message: string;
+    typeFormat: string;
+}>;
+export {};

package/dist/integrations/PushNotification/PushNotificationIntegration.d.ts

@@ -0,0 +1,78 @@
+import { EventTargetWithType } from "../../EventTarget";
+import { Startiapp } from "../../startiapp";
+import { Topic } from "./Topic";
+export declare class PushNotification extends EventTargetWithType<{
+    tokenRefreshed: CustomEvent<string>;
+    notificationReceived: CustomEvent<{
+        title: string;
+        body: string;
+    }>;
+}> {
+    private readonly startiapp;
+    private pushNotificationIntegration;
+    constructor(startiapp: Startiapp);
+    /**
+     * This method returns the token which should be used to send push notifications.
+     *
+     * @example
+     * ```typescript
+     * const fcmToken = await pushNotification.getToken();
+     * console.log(fcmToken);
+     * ```
+     */
+    getToken(): Promise<string>;
+    /**
+     * This method requests access to send push notifications to the user.
+     *
+     * @returns Boolean indicating whether the request was successful
+     *
+     * @example
+     * ```typescript
+     * const granted = await pushNotification.requestAccess();
+     * console.log(granted);
+     * ```
+     */
+    requestAccess(): Promise<boolean>;
+    /**
+     * Sets the badge count for the app.
+     *
+     * @param count - The number to set as the badge count.
+     */
+    setBadgeCount(count: number): void;
+    /**
+     * Retrieves the topics for push notifications.
+     *
+     * @returns An array of Topic objects representing the available topics.
+     * @throws Error if the request to get topics fails.
+     */
+    getTopics(): Promise<Topic[]>;
+    /**
+     * This method subscribes to a list of topics.
+     *
+     * @param topics List of topics to subscribe to
+     * @param shouldCheckAccess Boolean indicating whether to check for push notification permissions
+     *
+     * @example
+     * ```typescript
+     * await pushNotification.subscribeToTopics(["topic1", "topic2"]);
+     * ```
+     */
+    subscribeToTopics(topics: string[], shouldCheckAccess?: boolean): Promise<void>;
+    /**
+     * This method unsubscribes to a list of topics.
+     *
+     * @param topics List of topics to unsubscribe from
+     *
+     * @example
+     * ```typescript
+     * await pushNotification.unsubscribeFromTopics(["topic1", "topic2"]);
+     * ```
+     */
+    unsubscribeFromTopics(topics: string[]): Promise<void>;
+    private subscribeToAllTopicAsync;
+    private updateSubscribedStatusAsync;
+    private updateSubscribedTopics;
+    private getSubscribedTopics;
+    private onTokenReceived;
+    private onNotificationReceived;
+}

package/dist/integrations/PushNotification/Topic.d.ts

@@ -0,0 +1,15 @@
+import { StartiappClass } from "../../startiapp";
+export declare class Topic {
+    topic: string;
+    name: string;
+    subscribed: boolean;
+    private startiapp;
+    constructor(topic: string, name: string, subscribed: boolean, startiapp: StartiappClass);
+    toJSON(): {
+        topic: string;
+        name: string;
+        subscribed: boolean;
+    };
+    subscribe(): void;
+    unsubscribe(): void;
+}

package/dist/integrations/QrScanner/QrScannerIntegration.d.ts

@@ -0,0 +1,34 @@
+import { Startiapp } from "../../startiapp";
+export declare class QrScanner extends EventTarget {
+    private readonly startiapp;
+    private qrIntegration;
+    constructor(startiapp: Startiapp);
+    /**
+     * Starts the QR code scanner.
+     *
+     * @example
+     * ```typescript
+     * await qrScanner.scan();
+     * ```
+     */
+    scan(): Promise<void>;
+    /**
+     * Check if camera access is granted.
+     *
+     * @example
+     * ```typescript
+     * const isGranted = await qrScanner.isCameraAccessGranted();
+     * console.log(isGranted);
+     * ```
+     */
+    isCameraAccessGranted(): Promise<boolean>;
+    /**
+     * Requests the camera access.
+     *
+     * @example
+     * ```typescript
+     * await qrScanner.requestCameraAccess();
+     * ```
+     */
+    requestCameraAccess(): Promise<boolean>;
+}