@namiml/web-sdk 1.1.0 → 1.3.0

package/dist/nami/customer.d.ts

@@ -0,0 +1,91 @@
+import { Callback } from "src/types/components/containers";
+import { AccountStateAction } from "src/types/profile";
+type AccountStateHandler = (action: AccountStateAction, success: boolean, error?: Error) => void;
+/**
+ * NamiCustomerManager provides methods for managing customer-related functionality.
+ */
+export declare class NamiCustomerManager {
+    static instance: NamiCustomerManager;
+    private emitter;
+    /**
+     * Checks if the customer is logged in.
+     *
+     * @returns {boolean} Returns true if the customer is logged in, false otherwise.
+     */
+    static isLoggedIn(): boolean;
+    /**
+     * Returns the external ID of the currently logged in user.
+     *
+     * @returns The external ID of the logged in user.
+    */
+    static loggedInId(): string | undefined;
+    /**
+     * Logs in a customer with the specified ID.
+     *
+     * @param id - The ID of the customer to log in. Must be a SHA256 hash or UUID.
+     * @returns A Promise that resolves when the login is successful.
+    */
+    static login(externalId: string): Promise<void>;
+    static logout(): Promise<void>;
+    static setCustomerDataPlatformId(id: string): Promise<void>;
+    static clearCustomerDataPlatformId(): Promise<void>;
+    /**
+     * Registers a callback function to handle changes in the account state.
+     *
+     * @param callback - The callback function to be registered.
+     * @returns A function that can be used to unregister the original callback.
+     */
+    static registerAccountStateHandler(callback: AccountStateHandler): Callback;
+    /**
+     * Sets the anonymous mode for the customer.
+     *
+     * @param enabled - A boolean value indicating whether the anonymous mode should be enabled or disabled.
+     * @returns A Promise that resolves when the anonymous mode is set.
+     */
+    static setAnonymousMode(enabled: boolean): Promise<void>;
+    /**
+     * Returns whether or not the SDK is currently operating in anonymous mode
+     */
+    static inAnonymousMode(): boolean;
+    /**
+     * Sets an optional customer attributes that can be used to personalize your Nami paywalls.
+     *
+     * @param key - The name of the attribute. For example: `firstName`.
+     * @param value - The value of the customer attribute. For example: `Joe`.
+     */
+    static setCustomerAttribute(key: string, value: string): void;
+    /**
+     * Retrieves the value for a given key in the on-device customer attribute key/value store.
+     *
+     * @param key - The name of the attribute. For example: `firstName`
+     * @returns The value of the customer attribute.
+     */
+    static getCustomerAttribute(key: string): string | null;
+    /**
+     * Clears a value of the given key in the on-device key/value store.
+     *
+     * @param key - The key of the customer attribute to clear.
+     */
+    static clearCustomerAttribute(key: string): void;
+    /**
+     * Clear all customer attributes from the on-device key/value store.
+     *
+     */
+    static clearAllCustomerAttributes(): void;
+    /**
+     * Private Static Methods
+     */
+    private static invokeStateHandler;
+    /**
+     * Private Instance Methods
+     */
+    private get isSDKInitialized();
+    private static updateCustomerDataPlatformId;
+    /**
+   * Returns whether or not the configured app platform id belongs to an anonymous mode
+   * capable Nami account.
+   */
+    private static anonymousModeCapability;
+    private static refetchConfig;
+}
+export {};

package/dist/nami/emitter.d.ts

@@ -0,0 +1,12 @@
+export declare class NamiEventEmitter {
+    private static instance;
+    private emitter;
+    static getInstance(): NamiEventEmitter;
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+    emit(eventName: string, ...args: any[]): void;
+    addListener(eventName: string, listener: (...args: any[]) => void): void;
+    removeListener(eventName: string, listener: (...args: any[]) => void): void;
+    listeners(eventName: string): any[];
+    listenerCount(eventName: string): number;
+}

package/dist/nami/entitlement.d.ts

@@ -0,0 +1,29 @@
+import { NamiActiveEntitlementsHandler, NamiEntitlement } from "src/types/entitlements";
+import { Callback } from "src/types/components/containers";
+export declare class NamiEntitlementManager {
+    static instance: NamiEntitlementManager;
+    private emitter;
+    /**
+     * @returns list of currently active entitlements
+     */
+    static active(): NamiEntitlement[];
+    /**
+     * Checks if a Nami Control Center defined Entitlement has at least one backing purchase
+     * and it's not expired.
+     *
+     * @param referenceId - entitlement referenceId
+     * @returns True if the entitlement is active for given referenceId, false otherwise.
+     */
+    static isEntitlementActive(referenceId: string): boolean;
+    /**
+     * Asks Nami to fetch the latest active entitlements
+     *
+     * @returns list of NamiEntitlement
+     */
+    static refresh(): Promise<NamiEntitlement[]>;
+    static registerActiveEntitlementsHandler(handler: NamiActiveEntitlementsHandler): Callback | undefined;
+    /**
+     * Private Instance Methods
+     */
+    private get sdkInitialized();
+}

package/dist/nami/index.d.ts

@@ -0,0 +1,9 @@
+import { NamiConfiguration, NamiConfigurationState } from "src/types/config";
+export declare class Nami {
+    #private;
+    static instance: Nami;
+    get isInitialized(): boolean;
+    static configure(options: NamiConfiguration): Promise<NamiConfigurationState>;
+    private static setInitialConfig;
+    private initializeSDK;
+}

package/dist/nami/namiRefs.d.ts

@@ -0,0 +1,8 @@
+import { NamiConfiguration } from "src/types/config";
+export declare class NamiRefs {
+    static instance: NamiRefs;
+    init(config: NamiConfiguration): Promise<void>;
+    private setInitialValues;
+    private initAndFetchRequiredData;
+    private reRenderPaywall;
+}

package/dist/nami/paywalls.d.ts

@@ -0,0 +1,37 @@
+import { IPaywall } from "src/types/paywall";
+import { NamiProductDetails } from "src/types/externals/product";
+import { Callback } from "src/types/components/containers";
+import { NamiPurchaseDetails } from "src/types/externals/purchase";
+export declare class NamiPaywallManager {
+    static instance: NamiPaywallManager;
+    private emitter;
+    productDetails: NamiProductDetails[];
+    static allPaywalls(): IPaywall[];
+    static setProductDetails(productDetails: NamiProductDetails[]): void;
+    static registerSignInHandler(handler: Callback): Callback;
+    static registerCloseHandler(handler: Callback): Callback;
+    static registerDeeplinkActionHandler(handler: Callback): Callback;
+    static registerBuySkuHandler(handler: Callback): Callback;
+    static registerRestoreHandler(handler: Callback): Callback;
+    /**
+      * Notify the NamiPaywallManager that a purchase initiated from the
+      * [NamiBuySkuHandler] is complete. Only available for plans where Nami is
+      * not handling subscription & IAP management.
+      */
+    static buySkuComplete(purchase: NamiPurchaseDetails): Promise<void>;
+    /**
+       Notify the NamiPaywallManager that purchase flow handled by you is cancelled.
+       Used to disable product purchase-in-progress loading indicators
+    */
+    static buySkuCancel(): void;
+    /**
+      * Set the video details for the app supplied video
+      * @param url The URL of the video
+      * @param name The name of the video
+      */
+    static setAppSuppliedVideoDetails(url: string, name?: string): void;
+    /**
+     * Private Instance Methods
+     */
+    private get sdkInitialized();
+}

package/dist/nami/profile.d.ts

@@ -0,0 +1,12 @@
+export declare class NamiProfileManager {
+    static instance: NamiProfileManager;
+    private externalId?;
+    constructor();
+    setExternalId(externalId: string | undefined): NamiProfileManager;
+    getExternalId(): string | undefined;
+    isLoggedIn(): boolean;
+    private save;
+    private load;
+    login(externalId: string): Promise<void>;
+    logout(): Promise<void>;
+}

package/dist/nami/purchase.d.ts

@@ -0,0 +1,5 @@
+import { NamiPurchase } from "src/types/externals/purchase";
+export declare class NamiPurchaseManager {
+    static instance: NamiPurchaseManager;
+    static allPurchases(): NamiPurchase[];
+}

package/dist/nami/utils/campaign.d.ts

@@ -0,0 +1,8 @@
+import { NamiCampaign } from "src/types/externals/campaign";
+import { IPaywall } from "src/types/paywall";
+export declare const isValidUrl: (label: string) => boolean;
+export declare const allCampaigns: () => NamiCampaign[];
+export declare const getPaywallDataFromLabel: (value: string, type?: string) => {
+    campaign: NamiCampaign | undefined;
+    paywall: IPaywall | undefined;
+};

package/dist/nami/utils/entitlement.d.ts

@@ -0,0 +1,55 @@
+import { IEntitlements, NamiEntitlement } from "src/types/entitlements";
+import { NamiPurchase } from "src/types/externals/purchase";
+import { PaywallSKU, SKU } from "src/types/sku";
+import { NamiSKU } from "src/types/externals/sku";
+export declare class EntitlementUtils {
+    static instance: EntitlementUtils;
+    refIdToPurchasedSKUs: {
+        [key: string]: NamiSKU[];
+    };
+    refIdToRelatedSKUs: {
+        [key: string]: NamiSKU[];
+    };
+    refIdToActivePurchases: {
+        [key: string]: NamiPurchase[];
+    };
+}
+export declare const toNamiEntitlements: (entitlement: IEntitlements) => NamiEntitlement;
+export declare const setActiveNamiEntitlements: (entitlements: NamiEntitlement[]) => void;
+export declare const activeEntitlements: () => NamiEntitlement[];
+export declare const invokeHandler: () => void;
+export declare const getEntitlementRefIdsForSku: (purchasedSkuId: string) => string[];
+/**
+ * Populate a list of [NamiEntitlement] from the entitlements that have been provided by the
+ * app config. Also clears any previous list of [NamiEntitlement] from cache
+ */
+export declare const createNamiEntitlements: (entitlements?: IEntitlements[]) => NamiEntitlement[];
+/**
+ * For namiPurchase instance, it will have a purchasedSKU that will back the activation of
+ * the entitlement.
+ *
+ * The purchaseSku (pSKU) can then be used to retrieve all entitlements activated by that pSKU
+ *
+ * The entitlement will then be inspected to see if pSKU has yet to be tracked by that
+ * entitlement. If it has not, then it will be added.
+ *
+ * The entitlement will then be inspected to see if there any active purchases that match
+ * the NamiSKU. If there isn't any, then the NamiPurchase is then added to the
+ * entitlement's list of active purchases
+ */
+export declare const applyEntitlementActivation: (namiPurchase: NamiPurchase) => string[];
+/**
+   * Using the Nami Purchase object, look up the corresponding NamiSKU
+   * and set the NamiEntitlement associated to NamiSKU as an active entitlement
+   *
+   * @return List of strings where each string is a reference Id of an entitlement
+   * that was just successfully activated
+   */
+export declare const activateEntitlementByPurchase: (purchase: NamiPurchase) => string[];
+export declare const skuMapFromEntitlements: (entitlements?: IEntitlements[]) => {
+    [key: string]: NamiSKU[];
+};
+export declare const updateRelatedSKUsForNamiEntitlement: (entitlementRefId: string, entitlementRefIdToNamiSkus: {
+    [key: string]: NamiSKU[];
+}) => void;
+export declare function toNamiSKU(sku: PaywallSKU | SKU): NamiSKU;

package/dist/nami/utils/paywall.d.ts

@@ -0,0 +1,2 @@
+import { IPaywall } from "src/types/paywall";
+export declare const allPaywalls: () => IPaywall[];

package/dist/nami/utils/purchase.d.ts

@@ -0,0 +1,4 @@
+import { NamiPurchaseCompleteResult } from "src/types/purchase";
+import { NamiPurchaseDetails, NamiPurchase } from "src/types/externals/purchase";
+export declare function toNamiPurchase(purchase: NamiPurchaseDetails): NamiPurchase;
+export declare function namiBuySKU(skuRefId: string): NamiPurchaseCompleteResult | undefined;