@portkey/onboarding 0.0.2-alpha.2

package/README.md

@@ -0,0 +1,39 @@
+# `@portkey/onboarding`
+
+![ES Version](https://img.shields.io/badge/ES-2020-yellow)
+![Node Version](https://img.shields.io/badge/node-14.x-green)
+[![NPM Package Version][npm-image-version]][npm-url]
+
+## Installation
+
+### Using NPM
+
+```bash
+npm install @portkey/onboarding
+```
+
+### Using Yarn
+
+```bash
+yarn add @portkey/onboarding
+```
+
+## Prerequisites
+
+- :gear: [NodeJS](https://nodejs.org/) (LTS/Fermium)
+- :toolbox: [Yarn](https://yarnpkg.com/)/[Lerna](https://lerna.js.org/)
+
+## Package.json Scripts
+
+| Script   | Description                                        |
+| -------- | -------------------------------------------------- |
+| clean    | Uses `rm` to remove `dist/`                        |
+| build    | Uses `tsc` to build package and dependent packages |
+| lint     | Uses `eslint` to lint package                      |
+| lint:fix | Uses `eslint` to check and fix any warnings        |
+| format   | Uses `prettier` to format the code                 |
+
+## Usage
+
+[npm-image-version]: https://img.shields.io/npm/v/@portkey/onboarding
+[npm-url]: https://npmjs.org/package/@portkey/onboarding

package/dist/commonjs/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/commonjs/browser.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOriginalChrome = exports.isIos = exports.isAndroid = exports.getIOSVersion = exports.semverCompare = void 0;
+const ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';
+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;
+};
+exports.semverCompare = semverCompare;
+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);
+};
+exports.getIOSVersion = getIOSVersion;
+exports.isAndroid = /android/i.test(ua);
+exports.isIos = /iphone|ipad|ipod/i.test(ua);
+exports.isOriginalChrome = /chrome\/[\d.]+ mobile safari\/[\d.]+/i.test(ua) && exports.isAndroid && ua.indexOf('Version') < 0;

package/dist/commonjs/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/commonjs/constants/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEB_PAGE = exports.EXTENSION_DOWNLOAD_URL = exports.APP_DOWNLOAD_URL = void 0;
+exports.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',
+};
+exports.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',
+};
+exports.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/commonjs/evokeApp/evoke.d.ts

@@ -0,0 +1,22 @@
+import { OpenStatus } from './types';
+/**
+ * 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/commonjs/evokeApp/evoke.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkOpen = exports.evokeByIFrame = exports.evokeByTagA = exports.evokeByLocation = void 0;
+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
+ */
+function evokeByLocation(uri) {
+    // if (typeof window === 'undefined') return;
+    if (window.top)
+        window.top.location.href = uri;
+    else
+        window.location.href = uri;
+}
+exports.evokeByLocation = evokeByLocation;
+/**
+ * Evoked by the A tag
+ * @param {string} uri - open url
+ */
+function evokeByTagA(uri) {
+    const tagA = document.createElement('a');
+    tagA.setAttribute('href', uri);
+    tagA.style.display = 'none';
+    document.body.appendChild(tagA);
+    tagA.click();
+}
+exports.evokeByTagA = evokeByTagA;
+/**
+ * Evoked by iframe
+ * @param {string} [uri] - open url
+ */
+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;
+}
+exports.evokeByIFrame = evokeByIFrame;
+/**
+ * Check whether the calling end is successful
+ * @param cb - Callback failure callback function
+ * @param timeout
+ */
+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);
+    }
+}
+exports.checkOpen = checkOpen;

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

@@ -0,0 +1,5 @@
+import { EvokeAppConfig, EvokeAppOptions } from './types';
+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/commonjs/evokeApp/generate.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUniversalLink = exports.generateIntent = exports.generateScheme = exports.buildScheme = void 0;
+const query_string_1 = require("query-string");
+// Generate basic url scheme
+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 (0, query_string_1.stringifyUrl)({
+        url: `${protocol}://${domain}/${path}`,
+        query: param,
+    }, { encode: true });
+}
+exports.buildScheme = buildScheme;
+// Generate the url scheme required by the business (distinguish whether it is an external link)
+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;
+}
+exports.generateScheme = generateScheme;
+// generate android intent
+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}`;
+}
+exports.generateIntent = generateIntent;
+// generate universalLink
+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 = (0, query_string_1.stringifyUrl)({
+        url: `${protocol}://${domain}/${path}`,
+        query: param,
+    }, { encode: true });
+    const oldUniversalLink = (0, query_string_1.stringifyUrl)({
+        url: `${protocol}://${domain}/${path}`,
+        query: pathKey ? Object.assign({ [pathKey]: path }, param) : param,
+    }, { encode: true });
+    return pathKey ? oldUniversalLink : newUniversalLink;
+}
+exports.generateUniversalLink = generateUniversalLink;

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

@@ -0,0 +1,21 @@
+import { EvokeAppConfig, EvokeAppOptions } from './types';
+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/commonjs/evokeApp/index.js

@@ -0,0 +1,129 @@
+"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 __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.EvokeApp = void 0;
+/**
+ * @remakes https://github.com/suanmei/callapp-lib
+ */
+const Browser = __importStar(require("../browser"));
+const evoke_1 = require("./evoke");
+const generate = __importStar(require("./generate"));
+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) => {
+            (0, evoke_1.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(() => (0, evoke_1.evokeByLocation)(this.options.appStore));
+    }
+    // Redirect to the general (download) page if the terminal call fails
+    fallToFbUrl() {
+        this.checkOpen().catch(() => {
+            if (!this.options.fallback)
+                return;
+            (0, evoke_1.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) {
+                (0, evoke_1.evokeByIFrame)(schemeURL);
+                checkOpenFall = this.fallToAppStore;
+            }
+            else if (!supportUniversal) {
+                (0, evoke_1.evokeByTagA)(schemeURL);
+                checkOpenFall = this.fallToAppStore;
+            }
+            else {
+                (0, evoke_1.evokeByLocation)(this.generateUniversalLink(config));
+            }
+            // Android
+        }
+        else if (Browser.isOriginalChrome) {
+            if (typeof intent !== 'undefined') {
+                (0, evoke_1.evokeByLocation)(this.generateIntent(config));
+            }
+            else {
+                // The scheme cannot pull up the iframe normally on the android chrome25+ version
+                (0, evoke_1.evokeByLocation)(schemeURL);
+                checkOpenFall = this.fallToFbUrl;
+            }
+        }
+        else {
+            (0, evoke_1.evokeByIFrame)(schemeURL);
+            checkOpenFall = this.fallToFbUrl;
+        }
+        if (typeof callback !== 'undefined') {
+            this.fallToCustomCb(callback);
+            return;
+        }
+        if (!checkOpenFall)
+            return;
+        checkOpenFall.call(this);
+    }
+}
+exports.EvokeApp = EvokeApp;

package/dist/commonjs/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/commonjs/evokeApp/types.js

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

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

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

package/dist/commonjs/evokePortkey/checkPortkeyExtension.js

@@ -0,0 +1,44 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const detect_provider_1 = __importDefault(require("@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 (0, detect_provider_1.default)();
+            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 = (0, utils_1.detectBrowserName)();
+    const downloadURL = constants_1.EXTENSION_DOWNLOAD_URL[browserName] || constants_1.EXTENSION_DOWNLOAD_URL.DEFAULT;
+    _window.open(downloadURL, openTarget);
+    return false;
+});
+exports.default = checkPortkeyExtension;

package/dist/commonjs/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/commonjs/evokePortkey/evokeByThirdParty.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const query_string_1 = require("query-string");
+const constants_1 = require("../constants");
+const evokeByThirdParty = params => Promise.resolve(window.open(`${constants_1.WEB_PAGE}/portkey-download?${(0, query_string_1.stringify)(params)}`));
+exports.default = evokeByThirdParty;

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

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

package/dist/commonjs/evokePortkey/evokePortkeyApp.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@portkey/utils");
+const evokeApp_1 = require("../evokeApp");
+const constants_1 = require("../constants");
+const evokePortkeyApp = ({ domain, custom, action, timeout = 4000, customFailureCallback, onStatusChange, }) => {
+    const callLib = new evokeApp_1.EvokeApp({
+        scheme: {
+            protocol: utils_1.scheme.DID_APP_SCHEMA,
+            domain: domain || (window === null || window === void 0 ? void 0 : window.location.host),
+        },
+        timeout,
+        appStore: constants_1.APP_DOWNLOAD_URL.APP_STORE,
+        fallback: constants_1.APP_DOWNLOAD_URL.CHROME_STORE,
+        logFunc: onStatusChange,
+        buildScheme: (config, options) => {
+            return utils_1.scheme.formatScheme({
+                scheme: utils_1.scheme.DID_APP_SCHEMA,
+                action: action,
+                domain: options.scheme.domain,
+                custom: config.param,
+            });
+        },
+    });
+    callLib.open({
+        path: action,
+        param: custom,
+        callback: customFailureCallback,
+    });
+};
+exports.default = evokePortkeyApp;

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

@@ -0,0 +1,24 @@
+export * from './types';
+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/commonjs/evokePortkey/index.js

@@ -0,0 +1,25 @@
+"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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evokePortkey = void 0;
+const evokePortkeyApp_1 = __importDefault(require("./evokePortkeyApp"));
+const checkPortkeyExtension_1 = __importDefault(require("./checkPortkeyExtension"));
+const evokeByThirdParty_1 = __importDefault(require("./evokeByThirdParty"));
+__exportStar(require("./types"), exports);
+exports.evokePortkey = { app: evokePortkeyApp_1.default, extension: checkPortkeyExtension_1.default, thirdParty: evokeByThirdParty_1.default };