@portkey/onboarding 1.4.0-alpha.1

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,36 @@
+"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;
+        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,9 @@
+export declare const APP_DOWNLOAD_URL: {
+    APP_STORE: string;
+    CHROME_STORE: string;
+};
+export declare const EXTENSION_DOWNLOAD_URL: {
+    CHROME: string;
+    EDGE: string;
+    DEFAULT: string;
+};

package/dist/commonjs/constants/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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',
+};

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

@@ -0,0 +1,5 @@
+import { OpenStatus } from './types';
+export declare function evokeByLocation(uri: string): void;
+export declare function evokeByTagA(uri: string): void;
+export declare function evokeByIFrame(uri: string): void;
+export declare function checkOpen(callback: (status: OpenStatus) => void, timeout: number): void;

package/dist/commonjs/evokeApp/evoke.js

@@ -0,0 +1,79 @@
+"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') {
+        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();
+function isPageHidden() {
+    if (typeof document === 'undefined')
+        return false;
+    if (typeof hidden === 'undefined')
+        return false;
+    return document[hidden];
+}
+function evokeByLocation(uri) {
+    if (window.top)
+        window.top.location.href = uri;
+    else
+        window.location.href = uri;
+}
+exports.evokeByLocation = evokeByLocation;
+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;
+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;
+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,62 @@
+"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");
+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;
+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;
+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;
+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,13 @@
+import { EvokeAppConfig, EvokeAppOptions } from './types';
+export declare class EvokeApp {
+    private readonly options;
+    constructor(options: EvokeAppOptions);
+    generateScheme(config: EvokeAppConfig): string;
+    generateIntent(config: EvokeAppConfig): string;
+    generateUniversalLink(config: EvokeAppConfig): string;
+    checkOpen(): Promise<unknown>;
+    fallToAppStore(): void;
+    fallToFbUrl(): void;
+    fallToCustomCb(callback: () => void): void;
+    open(config: EvokeAppConfig): void;
+}

package/dist/commonjs/evokeApp/index.js

@@ -0,0 +1,112 @@
+"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;
+const Browser = __importStar(require("../browser"));
+const evoke_1 = require("./evoke");
+const generate = __importStar(require("./generate"));
+class EvokeApp {
+    constructor(options) {
+        const defaultOptions = { timeout: 4000 };
+        this.options = Object.assign(defaultOptions, options);
+    }
+    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);
+        });
+    }
+    fallToAppStore() {
+        this.checkOpen().catch(() => (0, evoke_1.evokeByLocation)(this.options.appStore));
+    }
+    fallToFbUrl() {
+        this.checkOpen().catch(() => {
+            if (!this.options.fallback)
+                return;
+            (0, evoke_1.evokeByLocation)(this.options.fallback);
+        });
+    }
+    fallToCustomCb(callback) {
+        this.checkOpen().catch(callback);
+    }
+    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));
+            }
+        }
+        else if (Browser.isOriginalChrome) {
+            if (typeof intent !== 'undefined') {
+                (0, evoke_1.evokeByLocation)(this.generateIntent(config));
+            }
+            else {
+                (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 @@
+export declare const checkPortkeyExtension: () => Promise<boolean>;

package/dist/commonjs/evokePortkey/checkPortkeyExtension.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPortkeyExtension = void 0;
+const utils_1 = require("@portkey/utils");
+const utils_2 = require("../utils");
+const constants_1 = require("../constants");
+const checkPortkeyExtension = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (typeof window === 'undefined')
+        return false;
+    const _window = window;
+    if (_window.portkey)
+        return true;
+    yield (0, utils_1.sleep)(1000);
+    if (_window.portkey)
+        return true;
+    const browserName = (0, utils_2.detectBrowserName)();
+    const downloadURL = constants_1.EXTENSION_DOWNLOAD_URL[browserName] || constants_1.EXTENSION_DOWNLOAD_URL.DEFAULT;
+    _window.open(downloadURL, '_blank');
+    return false;
+});
+exports.checkPortkeyExtension = checkPortkeyExtension;

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

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

package/dist/commonjs/evokePortkey/evokePortkeyApp.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evokePortkeyApp = void 0;
+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.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.evokePortkeyApp = evokePortkeyApp;

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

@@ -0,0 +1,2 @@
+export * from './evokePortkeyApp';
+export * from './checkPortkeyExtension';

package/dist/commonjs/evokePortkey/index.js

@@ -0,0 +1,18 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./evokePortkeyApp"), exports);
+__exportStar(require("./checkPortkeyExtension"), exports);

package/dist/commonjs/index.d.ts

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

package/dist/commonjs/index.js

@@ -0,0 +1,32 @@
+"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);

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,31 @@
+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;
+        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,9 @@
+export declare const APP_DOWNLOAD_URL: {
+    APP_STORE: string;
+    CHROME_STORE: string;
+};
+export declare const EXTENSION_DOWNLOAD_URL: {
+    CHROME: string;
+    EDGE: string;
+    DEFAULT: string;
+};