@portkey/onboarding 0.0.2-alpha.2

package/dist/commonjs/evokePortkey/types.d.ts

@@ -0,0 +1,21 @@
+import { PartialOption } from '@portkey/types';
+import { EvokeAppOptions } from '../evokeApp/types';
+import { scheme as schemeUtils } from '@portkey/utils';
+export interface IBaseEvokeAppOption {
+    timeout?: number;
+    customFailureCallback?: () => void;
+    onStatusChange?: EvokeAppOptions['logFunc'];
+}
+export type EvokePortkeyByLogin = PartialOption<Omit<schemeUtils.ILoginHandleSchemeParams, 'scheme'>, 'domain'> & IBaseEvokeAppOption;
+export type EvokePortkeyByLinkDapp = PartialOption<Omit<schemeUtils.ILinkDappHandleSchemeParams, 'scheme'>, 'domain'> & IBaseEvokeAppOption;
+export type EvokePortkeyByAddContact = PartialOption<Omit<schemeUtils.IAddContactHandleSchemeParams, 'scheme'>, 'domain'> & IBaseEvokeAppOption;
+export type EvokePortkeyByAddGroup = PartialOption<Omit<schemeUtils.IAddGroupHandleSchemeParams, 'scheme'>, 'domain'> & IBaseEvokeAppOption;
+export interface IEvokePortkeyApp {
+    evokePortkeyApp(params: EvokePortkeyByLogin): void;
+    evokePortkeyApp(params: EvokePortkeyByLinkDapp): void;
+    evokePortkeyApp(params: EvokePortkeyByAddContact): void;
+    evokePortkeyApp(params: EvokePortkeyByAddGroup): void;
+}
+export interface IEvokeExtensionProps {
+    openTarget?: '_self' | '_blank';
+}

package/dist/commonjs/evokePortkey/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commonjs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './evokeApp';
+export * as Browser from './browser';
+export * from './evokePortkey';
+export * from './utils';

package/dist/commonjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Browser = void 0;
+__exportStar(require("./evokeApp"), exports);
+exports.Browser = __importStar(require("./browser"));
+__exportStar(require("./evokePortkey"), exports);
+__exportStar(require("./utils"), exports);

package/dist/commonjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/commonjs/utils/index.d.ts

@@ -0,0 +1 @@
+export declare const detectBrowserName: () => string;

package/dist/commonjs/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectBrowserName = void 0;
+const bowser_1 = __importDefault(require("bowser"));
+const detectBrowserName = () => {
+    if (typeof navigator === 'undefined')
+        return '';
+    const browserInfo = bowser_1.default.parse(window.navigator.userAgent);
+    if (browserInfo.browser.name === 'Firefox') {
+        return 'FIREFOX';
+    }
+    else if (['Chrome', 'Chromium'].includes(browserInfo.browser.name || '')) {
+        return 'CHROME';
+    }
+    else if (browserInfo.browser.name === 'Microsoft Edge') {
+        return 'EDGE';
+    }
+    return browserInfo.browser.name || '';
+};
+exports.detectBrowserName = detectBrowserName;

package/dist/esm/browser.d.ts

@@ -0,0 +1,5 @@
+export declare const semverCompare: (verionA: string, versionB: string) => -1 | 0 | 1;
+export declare const getIOSVersion: () => number;
+export declare const isAndroid: boolean;
+export declare const isIos: boolean;
+export declare const isOriginalChrome: boolean;

package/dist/esm/browser.js

@@ -0,0 +1,32 @@
+const ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';
+export const semverCompare = (verionA, versionB) => {
+    const { isNaN } = window;
+    const splitA = verionA.split('.');
+    const splitB = versionB.split('.');
+    for (let i = 0; i < 3; i++) {
+        const snippetA = Number(splitA[i]);
+        const snippetB = Number(splitB[i]);
+        if (snippetA > snippetB)
+            return 1;
+        if (snippetB > snippetA)
+            return -1;
+        // e.g. '1.0.0-rc' -- Number('0-rc') = NaN
+        if (!isNaN(snippetA) && isNaN(snippetB))
+            return 1;
+        if (isNaN(snippetA) && !isNaN(snippetB))
+            return -1;
+    }
+    return 0;
+};
+export const getIOSVersion = () => {
+    var _a;
+    const version = (_a = ua
+        .toLocaleLowerCase()
+        .match(/cpu iphone os (.*?) like mac os/)) === null || _a === void 0 ? void 0 : _a[1].split('_');
+    if (!version)
+        return -1;
+    return Number.parseInt(version[0], 10);
+};
+export const isAndroid = /android/i.test(ua);
+export const isIos = /iphone|ipad|ipod/i.test(ua);
+export const isOriginalChrome = /chrome\/[\d.]+ mobile safari\/[\d.]+/i.test(ua) && isAndroid && ua.indexOf('Version') < 0;

package/dist/esm/constants/index.d.ts

@@ -0,0 +1,10 @@
+export declare const APP_DOWNLOAD_URL: {
+    APP_STORE: string;
+    CHROME_STORE: string;
+};
+export declare const EXTENSION_DOWNLOAD_URL: {
+    CHROME: string;
+    EDGE: string;
+    DEFAULT: string;
+};
+export declare const WEB_PAGE = "https://openlogin.portkey.finance";

package/dist/esm/constants/index.js

@@ -0,0 +1,12 @@
+export const APP_DOWNLOAD_URL = {
+    APP_STORE: 'https://apps.apple.com/us/app/portkey-ca-wallet-crypto-nft/id6445808228',
+    CHROME_STORE: 'https://play.google.com/store/apps/details?id=com.portkey.did',
+};
+export const EXTENSION_DOWNLOAD_URL = {
+    CHROME: 'https://chrome.google.com/webstore/detail/portkey-did-crypto-nft/hpjiiechbbhefmpggegmahejiiphbmij',
+    EDGE: 'https://chrome.google.com/webstore/detail/portkey-did-crypto-nft/hpjiiechbbhefmpggegmahejiiphbmij',
+    DEFAULT: 'https://portkey.finance/download',
+};
+export const WEB_PAGE = 'https://openlogin.portkey.finance';
+// export const WEB_PAGE = 'https://openlogin-test.portkey.finance';
+// export const WEB_PAGE = 'http://192.168.11.245:3000';

package/dist/esm/evokeApp/evoke.d.ts

@@ -0,0 +1,22 @@
+import { OpenStatus } from './types.js';
+/**
+ * Jump via top.location.href
+ * @param {string} [uri] - open
+ */
+export declare function evokeByLocation(uri: string): void;
+/**
+ * Evoked by the A tag
+ * @param {string} uri - open url
+ */
+export declare function evokeByTagA(uri: string): void;
+/**
+ * Evoked by iframe
+ * @param {string} [uri] - open url
+ */
+export declare function evokeByIFrame(uri: string): void;
+/**
+ * Check whether the calling end is successful
+ * @param cb - Callback failure callback function
+ * @param timeout
+ */
+export declare function checkOpen(callback: (status: OpenStatus) => void, timeout: number): void;

package/dist/esm/evokeApp/evoke.js

@@ -0,0 +1,94 @@
+let hidden = 'hidden';
+let visibilityChange = 'visibilitychange';
+let iframe;
+function getSupportedProperty() {
+    if (typeof document === 'undefined')
+        return;
+    if (typeof document.hidden !== 'undefined') {
+        // Opera 12.10 and Firefox 18 and later support
+        hidden = 'hidden';
+        visibilityChange = 'visibilitychange';
+    }
+    else if (typeof document.msHidden !== 'undefined') {
+        hidden = 'msHidden';
+        visibilityChange = 'msvisibilitychange';
+    }
+    else if (typeof document.webkitHidden !== 'undefined') {
+        hidden = 'webkitHidden';
+        visibilityChange = 'webkitvisibilitychange';
+    }
+}
+getSupportedProperty();
+/**
+ * Determine whether the page is hidden (enter the background)
+ */
+function isPageHidden() {
+    if (typeof document === 'undefined')
+        return false;
+    if (typeof hidden === 'undefined')
+        return false;
+    return document[hidden];
+}
+/**
+ * Jump via top.location.href
+ * @param {string} [uri] - open
+ */
+export function evokeByLocation(uri) {
+    // if (typeof window === 'undefined') return;
+    if (window.top)
+        window.top.location.href = uri;
+    else
+        window.location.href = uri;
+}
+/**
+ * Evoked by the A tag
+ * @param {string} uri - open url
+ */
+export function evokeByTagA(uri) {
+    const tagA = document.createElement('a');
+    tagA.setAttribute('href', uri);
+    tagA.style.display = 'none';
+    document.body.appendChild(tagA);
+    tagA.click();
+}
+/**
+ * Evoked by iframe
+ * @param {string} [uri] - open url
+ */
+export function evokeByIFrame(uri) {
+    if (!iframe) {
+        iframe = document.createElement('iframe');
+        iframe.style.cssText = 'display:none;border:0;width:0;height:0;';
+        document.body.appendChild(iframe);
+    }
+    iframe.src = uri;
+}
+/**
+ * Check whether the calling end is successful
+ * @param cb - Callback failure callback function
+ * @param timeout
+ */
+export function checkOpen(callback, timeout) {
+    const timer = setTimeout(() => {
+        const pageHidden = isPageHidden();
+        if (!pageHidden) {
+            callback('failure');
+            if (typeof visibilityChange !== 'undefined') {
+                document.removeEventListener(visibilityChange, visibilityListenHandler);
+            }
+            else {
+                window.removeEventListener('pagehide', visibilityListenHandler);
+            }
+        }
+    }, timeout);
+    const visibilityListenHandler = () => {
+        clearTimeout(timer);
+        callback('success');
+    };
+    if (typeof visibilityChange !== 'undefined') {
+        document.addEventListener(visibilityChange, visibilityListenHandler);
+    }
+    else {
+        window.addEventListener('pagehide', visibilityListenHandler);
+    }
+}

package/dist/esm/evokeApp/generate.d.ts

@@ -0,0 +1,5 @@
+import { EvokeAppConfig, EvokeAppOptions } from './types.js';
+export declare function buildScheme(config: EvokeAppConfig, options: EvokeAppOptions): string;
+export declare function generateScheme(config: EvokeAppConfig, options: EvokeAppOptions): string;
+export declare function generateIntent(config: EvokeAppConfig, options: EvokeAppOptions): string;
+export declare function generateUniversalLink(config: EvokeAppConfig, options: EvokeAppOptions): string;

package/dist/esm/evokeApp/generate.js

@@ -0,0 +1,59 @@
+import { stringifyUrl } from 'query-string';
+// Generate basic url scheme
+export function buildScheme(config, options) {
+    const { path, param } = config;
+    const { scheme, buildScheme: customBuildScheme } = options;
+    if (typeof customBuildScheme !== 'undefined') {
+        return customBuildScheme(config, options);
+    }
+    const { domain, protocol } = scheme;
+    return stringifyUrl({
+        url: `${protocol}://${domain}/${path}`,
+        query: param,
+    }, { encode: true });
+}
+// Generate the url scheme required by the business (distinguish whether it is an external link)
+export function generateScheme(config, options) {
+    const { outChain } = options;
+    let uri = buildScheme(config, options);
+    if (typeof outChain !== 'undefined' && outChain) {
+        const { protocol, path, key } = outChain;
+        uri = `${protocol}://${path}?${key}=${encodeURIComponent(uri)}`;
+    }
+    return uri;
+}
+// generate android intent
+export function generateIntent(config, options) {
+    const { outChain } = options;
+    const { intent, fallback } = options;
+    if (typeof intent === 'undefined')
+        return '';
+    const keys = Object.keys(intent);
+    const intentParam = keys.map(key => `${key}=${intent[key]};`).join('');
+    const intentTail = `#Intent;${intentParam}S.browser_fallback_url=${encodeURIComponent(fallback || '')};end;`;
+    let urlPath = buildScheme(config, options);
+    if (typeof outChain !== 'undefined' && outChain) {
+        const { path, key } = outChain;
+        return `intent://${path}?${key}=${encodeURIComponent(urlPath)}${intentTail}`;
+    }
+    urlPath = urlPath.slice(urlPath.indexOf('//') + 2);
+    return `intent://${urlPath}${intentTail}`;
+}
+// generate universalLink
+export function generateUniversalLink(config, options) {
+    const { universal } = options;
+    if (typeof universal === 'undefined')
+        return '';
+    const { domain, pathKey } = universal;
+    const { path, param } = config;
+    const protocol = 'https';
+    const newUniversalLink = stringifyUrl({
+        url: `${protocol}://${domain}/${path}`,
+        query: param,
+    }, { encode: true });
+    const oldUniversalLink = stringifyUrl({
+        url: `${protocol}://${domain}/${path}`,
+        query: pathKey ? Object.assign({ [pathKey]: path }, param) : param,
+    }, { encode: true });
+    return pathKey ? oldUniversalLink : newUniversalLink;
+}

package/dist/esm/evokeApp/index.d.ts

@@ -0,0 +1,21 @@
+import { EvokeAppConfig, EvokeAppOptions } from './types.js';
+export declare class EvokeApp {
+    private readonly options;
+    constructor(options: EvokeAppOptions);
+    /**
+     * register as method
+     * generateScheme | generateIntent | generateUniversalLink  | checkOpen
+     */
+    generateScheme(config: EvokeAppConfig): string;
+    generateIntent(config: EvokeAppConfig): string;
+    generateUniversalLink(config: EvokeAppConfig): string;
+    checkOpen(): Promise<unknown>;
+    fallToAppStore(): void;
+    fallToFbUrl(): void;
+    fallToCustomCb(callback: () => void): void;
+    /**
+     * Evoke the client
+     * Execute different call-out strategies according to different browsers
+     */
+    open(config: EvokeAppConfig): void;
+}

package/dist/esm/evokeApp/index.js

@@ -0,0 +1,102 @@
+/**
+ * @remakes https://github.com/suanmei/callapp-lib
+ */
+import * as Browser from '../browser.js';
+import { evokeByLocation, evokeByIFrame, checkOpen, evokeByTagA } from './evoke.js';
+import * as generate from './generate.js';
+export class EvokeApp {
+    // Create an instance of EvokeApp
+    constructor(options) {
+        const defaultOptions = { timeout: 4000 };
+        this.options = Object.assign(defaultOptions, options);
+    }
+    /**
+     * register as method
+     * generateScheme | generateIntent | generateUniversalLink  | checkOpen
+     */
+    generateScheme(config) {
+        return generate.generateScheme(config, this.options);
+    }
+    generateIntent(config) {
+        return generate.generateIntent(config, this.options);
+    }
+    generateUniversalLink(config) {
+        return generate.generateUniversalLink(config, this.options);
+    }
+    checkOpen() {
+        const { logFunc, timeout } = this.options;
+        return new Promise((resolve, reject) => {
+            checkOpen(status => {
+                logFunc === null || logFunc === void 0 ? void 0 : logFunc(status);
+                if (status === 'success')
+                    return resolve(status);
+                reject(status);
+            }, timeout);
+        });
+    }
+    // Call terminal failure jump app store
+    fallToAppStore() {
+        this.checkOpen().catch(() => evokeByLocation(this.options.appStore));
+    }
+    // Redirect to the general (download) page if the terminal call fails
+    fallToFbUrl() {
+        this.checkOpen().catch(() => {
+            if (!this.options.fallback)
+                return;
+            evokeByLocation(this.options.fallback);
+        });
+    }
+    // Failed to call the terminal to call the custom callback function
+    fallToCustomCb(callback) {
+        this.checkOpen().catch(callback);
+    }
+    /**
+     * Evoke the client
+     * Execute different call-out strategies according to different browsers
+     */
+    open(config) {
+        const { universal, logFunc, intent } = this.options;
+        const { callback } = config;
+        const supportUniversal = typeof universal !== 'undefined';
+        const schemeURL = this.generateScheme(config);
+        let checkOpenFall;
+        if (typeof logFunc !== 'undefined') {
+            logFunc('pending');
+        }
+        if (Browser.isIos) {
+            if (Browser.getIOSVersion() < 9) {
+                evokeByIFrame(schemeURL);
+                checkOpenFall = this.fallToAppStore;
+            }
+            else if (!supportUniversal) {
+                evokeByTagA(schemeURL);
+                checkOpenFall = this.fallToAppStore;
+            }
+            else {
+                evokeByLocation(this.generateUniversalLink(config));
+            }
+            // Android
+        }
+        else if (Browser.isOriginalChrome) {
+            if (typeof intent !== 'undefined') {
+                evokeByLocation(this.generateIntent(config));
+            }
+            else {
+                // The scheme cannot pull up the iframe normally on the android chrome25+ version
+                evokeByLocation(schemeURL);
+                checkOpenFall = this.fallToFbUrl;
+            }
+        }
+        else {
+            evokeByIFrame(schemeURL);
+            checkOpenFall = this.fallToFbUrl;
+        }
+        if (typeof callback !== 'undefined') {
+            this.fallToCustomCb(callback);
+            return;
+        }
+        if (!checkOpenFall)
+            return;
+        checkOpenFall.call(this);
+    }
+}

package/dist/esm/evokeApp/types.d.ts

@@ -0,0 +1,37 @@
+import { StringifiableRecord } from 'query-string';
+export interface EvokeAppConfig<Params = StringifiableRecord> {
+    path: string;
+    param?: Params;
+    callback?: () => void;
+}
+export interface EvokeAppOptions {
+    scheme: {
+        protocol: string;
+        domain: string;
+    };
+    outChain?: {
+        protocol: string;
+        path: string;
+        key: string;
+    };
+    intent?: Intent;
+    universal?: {
+        domain: string;
+        pathKey?: string;
+    };
+    appStore: string;
+    fallback?: string;
+    timeout?: number;
+    logFunc?: (status: 'pending' | 'failure' | 'success') => void;
+    buildScheme?: (config: EvokeAppConfig, options: EvokeAppOptions) => string;
+}
+export interface Intent {
+    package: string;
+    scheme: string;
+    action?: string;
+    category?: string;
+    component?: string;
+}
+export type Hidden = 'hidden' | 'webkitHidden' | 'msHidden' | undefined;
+export type VisibilityChange = 'visibilitychange' | 'webkitvisibilitychange' | 'msvisibilitychange' | undefined;
+export type OpenStatus = 'failure' | 'success';

package/dist/esm/evokeApp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/evokePortkey/checkPortkeyExtension.d.ts

@@ -0,0 +1,3 @@
+import { IEvokeExtensionProps } from './types.js';
+declare const checkPortkeyExtension: (params?: IEvokeExtensionProps) => Promise<boolean>;
+export default checkPortkeyExtension;

package/dist/esm/evokePortkey/checkPortkeyExtension.js

@@ -0,0 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { detectBrowserName } from '../utils/index.js';
+import { EXTENSION_DOWNLOAD_URL } from '../constants/index.js';
+import detectProvider from '@portkey/detect-provider';
+/**
+ * This method is used to check if the provided object is a Portkey provider.
+ */
+function isPortkeyProvider() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const provider = yield detectProvider();
+            return !!provider;
+        }
+        catch (error) {
+            return false;
+        }
+    });
+}
+const checkPortkeyExtension = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const openTarget = params === null || params === void 0 ? void 0 : params.openTarget;
+    if (typeof window === 'undefined')
+        return false;
+    const _window = window;
+    if (yield isPortkeyProvider())
+        return true;
+    const browserName = detectBrowserName();
+    const downloadURL = EXTENSION_DOWNLOAD_URL[browserName] || EXTENSION_DOWNLOAD_URL.DEFAULT;
+    _window.open(downloadURL, openTarget);
+    return false;
+});
+export default checkPortkeyExtension;

package/dist/esm/evokePortkey/evokeByThirdParty.d.ts

@@ -0,0 +1,16 @@
+import { scheme } from '@portkey/utils';
+type IBaseOption = {
+    timeout?: number;
+};
+interface IEvokeByThirdParty {
+    evokeByThirdParty(params?: {
+        action: 'login';
+        custom: scheme.ILoginHandleSchemeParams['custom'];
+    } & IBaseOption): Promise<any>;
+    evokeByThirdParty(params?: {
+        action: 'linkDapp';
+        custom: scheme.ILinkDappHandleSchemeParams['custom'];
+    } & IBaseOption): Promise<any>;
+}
+declare const evokeByThirdParty: IEvokeByThirdParty['evokeByThirdParty'];
+export default evokeByThirdParty;

package/dist/esm/evokePortkey/evokeByThirdParty.js

@@ -0,0 +1,4 @@
+import { stringify } from 'query-string';
+import { WEB_PAGE } from '../constants/index.js';
+const evokeByThirdParty = params => Promise.resolve(window.open(`${WEB_PAGE}/portkey-download?${stringify(params)}`));
+export default evokeByThirdParty;

package/dist/esm/evokePortkey/evokePortkeyApp.d.ts

@@ -0,0 +1,3 @@
+import { IEvokePortkeyApp } from './types.js';
+declare const evokePortkeyApp: IEvokePortkeyApp['evokePortkeyApp'];
+export default evokePortkeyApp;

package/dist/esm/evokePortkey/evokePortkeyApp.js

@@ -0,0 +1,29 @@
+import { scheme as schemeUtils } from '@portkey/utils';
+import { EvokeApp } from '../evokeApp/index.js';
+import { APP_DOWNLOAD_URL } from '../constants/index.js';
+const evokePortkeyApp = ({ domain, custom, action, timeout = 4000, customFailureCallback, onStatusChange, }) => {
+    const callLib = new EvokeApp({
+        scheme: {
+            protocol: schemeUtils.DID_APP_SCHEMA,
+            domain: domain || (window === null || window === void 0 ? void 0 : window.location.host),
+        },
+        timeout,
+        appStore: APP_DOWNLOAD_URL.APP_STORE,
+        fallback: APP_DOWNLOAD_URL.CHROME_STORE,
+        logFunc: onStatusChange,
+        buildScheme: (config, options) => {
+            return schemeUtils.formatScheme({
+                scheme: schemeUtils.DID_APP_SCHEMA,
+                action: action,
+                domain: options.scheme.domain,
+                custom: config.param,
+            });
+        },
+    });
+    callLib.open({
+        path: action,
+        param: custom,
+        callback: customFailureCallback,
+    });
+};
+export default evokePortkeyApp;

package/dist/esm/evokePortkey/index.d.ts

@@ -0,0 +1,24 @@
+export * from './types.js';
+export declare const evokePortkey: {
+    app: {
+        (params: import("./types").EvokePortkeyByLogin): void;
+        (params: import("./types").EvokePortkeyByLinkDapp): void;
+        (params: import("./types").EvokePortkeyByAddContact): void;
+        (params: import("./types").EvokePortkeyByAddGroup): void;
+    };
+    extension: (params?: import("./types").IEvokeExtensionProps | undefined) => Promise<boolean>;
+    thirdParty: {
+        (params?: ({
+            action: "login";
+            custom: any;
+        } & {
+            timeout?: number | undefined;
+        }) | undefined): Promise<any>;
+        (params?: ({
+            action: "linkDapp";
+            custom: import("@portkey/utils/dist/commonjs/scheme").LinkDappData;
+        } & {
+            timeout?: number | undefined;
+        }) | undefined): Promise<any>;
+    };
+};

package/dist/esm/evokePortkey/index.js

@@ -0,0 +1,5 @@
+import app from './evokePortkeyApp.js';
+import extension from './checkPortkeyExtension.js';
+import thirdParty from './evokeByThirdParty.js';
+export * from './types.js';
+export const evokePortkey = { app, extension, thirdParty };