@dynamic-labs/utils 3.0.0-alpha.9 → 3.0.0

package/src/nativeMobileOauthStateParam.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents the value that separates the random string from the
+ * mobile deeplink URL in the state param from the oauth messages
+ * emitted from native mobile apps.
+ */
+export declare const nativeMobileOauthStateParam = "_client-redirect:";
+/**
+ * Represents the format of the state variable exchanged in oauth2 messages
+ * by native mobile devices.
+ *
+ * It has a random state string followed byt the client redirect URL as configured
+ * in the Client.
+ */
+export type NativeMobileOauthState = `${string}${typeof nativeMobileOauthStateParam}${string}`;

package/src/nativeMobileOauthStateParam.js

@@ -0,0 +1,9 @@
+'use client'
+/**
+ * Represents the value that separates the random string from the
+ * mobile deeplink URL in the state param from the oauth messages
+ * emitted from native mobile apps.
+ */
+const nativeMobileOauthStateParam = '_client-redirect:';
+
+export { nativeMobileOauthStateParam };

package/src/retryableFn.cjs

@@ -4,12 +4,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../_virtual/_tslib.cjs');
-require('./errors/InsufficientFundsError.cjs');
-require('./errors/TransactionGasCannotBeSponsoredError.cjs');
-require('./logger/logger.cjs');
-require('./bufferPolyfill.cjs');
 var sleep = require('./sleep/sleep.cjs');
-require('tldts');
 
 const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
 const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {
@@ -67,6 +62,7 @@ const retryableFn = (fn_1, ...args_1) => _tslib.__awaiter(void 0, [fn_1, ...args
             fallbackValue,
             logger,
             maxRetries,
+            retryIntervalMs,
             retryStrategy,
             timeoutMs,
         });

package/src/retryableFn.js

@@ -1,11 +1,6 @@
 'use client'
 import { __awaiter } from '../_virtual/_tslib.js';
-import './errors/InsufficientFundsError.js';
-import './errors/TransactionGasCannotBeSponsoredError.js';
-import './logger/logger.js';
-import './bufferPolyfill.js';
 import { sleep } from './sleep/sleep.js';
-import 'tldts';
 
 const FALLBACK_UNDEFINED = 'FALLBACK_UNDEFINED';
 const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], void 0, function* (fn, options = {}) {
@@ -63,6 +58,7 @@ const retryableFn = (fn_1, ...args_1) => __awaiter(void 0, [fn_1, ...args_1], vo
             fallbackValue,
             logger,
             maxRetries,
+            retryIntervalMs,
             retryStrategy,
             timeoutMs,
         });

package/src/services/FetchService/FetchService.cjs

@@ -3,22 +3,27 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+var _a, _FetchService_implementation;
 /**
  * Class implementing the fetch service with a configurable fetch implementation.
  */
 class FetchService {
     static get implementation() {
-        if (!FetchService._implementation) {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation)) {
             return { fetch: window.fetch.bind(window) };
         }
-        return FetchService._implementation;
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation);
     }
-    static setImplementation(implementation) {
-        FetchService._implementation = implementation;
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _FetchService_implementation);
     }
     static get fetch() {
-        return FetchService.implementation.fetch;
+        return _a.implementation.fetch;
     }
 }
+_a = FetchService;
+_FetchService_implementation = { value: void 0 };
 
 exports.FetchService = FetchService;

package/src/services/FetchService/FetchService.d.ts

@@ -3,8 +3,8 @@ import { IFetchService } from './types';
  * Class implementing the fetch service with a configurable fetch implementation.
  */
 export declare class FetchService {
-    static _implementation: IFetchService;
+    #private;
     static get implementation(): IFetchService;
-    static setImplementation(implementation: IFetchService): void;
+    static set implementation(implementation: IFetchService);
     static get fetch(): (input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>;
 }

package/src/services/FetchService/FetchService.js

@@ -1,20 +1,25 @@
 'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+
+var _a, _FetchService_implementation;
 /**
  * Class implementing the fetch service with a configurable fetch implementation.
  */
 class FetchService {
     static get implementation() {
-        if (!FetchService._implementation) {
+        if (!__classPrivateFieldGet(_a, _a, "f", _FetchService_implementation)) {
             return { fetch: window.fetch.bind(window) };
         }
-        return FetchService._implementation;
+        return __classPrivateFieldGet(_a, _a, "f", _FetchService_implementation);
     }
-    static setImplementation(implementation) {
-        FetchService._implementation = implementation;
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _FetchService_implementation);
     }
     static get fetch() {
-        return FetchService.implementation.fetch;
+        return _a.implementation.fetch;
     }
 }
+_a = FetchService;
+_FetchService_implementation = { value: void 0 };
 
 export { FetchService };

package/src/services/Oauth2Service/Oauth2Service.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var types = require('@dynamic-labs/types');
+var createWindowOauth2Service = require('./createWindowOauth2Service/createWindowOauth2Service.cjs');
+
+var _a, _Oauth2Service_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!_tslib.__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation)) {
+            return createWindowOauth2Service.createWindowOauth2Service();
+        }
+        return _tslib.__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation);
+    }
+    static set implementation(implementation) {
+        _tslib.__classPrivateFieldSet(_a, _a, implementation, "f", _Oauth2Service_implementation);
+    }
+    static get getOauthCode() {
+        return _a.implementation.getOauthCode;
+    }
+}
+_a = Oauth2Service;
+_Oauth2Service_implementation = { value: void 0 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Oauth2Service.isGetOauthCodeError = (error) => error === 'user-cancelled' ||
+    (typeof error === 'object' &&
+        'code' in error &&
+        Object.values(types.SocialOAuthErrorCode).includes(error.code) &&
+        'message' in error &&
+        typeof error.message === 'string');
+
+exports.Oauth2Service = Oauth2Service;

package/src/services/Oauth2Service/Oauth2Service.d.ts

@@ -0,0 +1,41 @@
+import { OauthResultResponse, Provider, ProviderEnum } from '@dynamic-labs/sdk-api-core';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+export type GetOauthCodeProps = {
+    provider: ProviderEnum;
+    apiProvider: Provider | undefined;
+    setIsProcessing: (value: boolean) => void;
+    onSettled?: VoidFunction;
+    getOAuthResultFromApi: () => Promise<OauthResultResponse | undefined>;
+    initWebAuth: (options?: {
+        redirectUrl?: string;
+    }) => Promise<void>;
+    state: string;
+    oauthLoginUrl: URL;
+    /**
+     * The preferred strategy to use for the OAuth2 flow.
+     */
+    strategy: 'popup' | 'redirect';
+    sessionTimeout: number;
+    /**
+     * Overrides the default redirectUrl coming from the DynamicContextProvider
+     */
+    redirectUrl?: string;
+    isMobile?: boolean;
+};
+export type IOauth2Service = {
+    getOauthCode: (props: GetOauthCodeProps) => Promise<string>;
+};
+export type GetOauthCodeError = 'user-cancelled' | {
+    code: SocialOAuthErrorCode;
+    message: string;
+};
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+export declare class Oauth2Service {
+    #private;
+    static get implementation(): IOauth2Service;
+    static set implementation(implementation: IOauth2Service);
+    static get getOauthCode(): (props: GetOauthCodeProps) => Promise<string>;
+    static isGetOauthCodeError: (error: any) => error is GetOauthCodeError;
+}

package/src/services/Oauth2Service/Oauth2Service.js

@@ -0,0 +1,34 @@
+'use client'
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../_virtual/_tslib.js';
+import { SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { createWindowOauth2Service } from './createWindowOauth2Service/createWindowOauth2Service.js';
+
+var _a, _Oauth2Service_implementation;
+/**
+ * Class implementing the fetch service with a configurable fetch implementation.
+ */
+class Oauth2Service {
+    static get implementation() {
+        if (!__classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation)) {
+            return createWindowOauth2Service();
+        }
+        return __classPrivateFieldGet(_a, _a, "f", _Oauth2Service_implementation);
+    }
+    static set implementation(implementation) {
+        __classPrivateFieldSet(_a, _a, implementation, "f", _Oauth2Service_implementation);
+    }
+    static get getOauthCode() {
+        return _a.implementation.getOauthCode;
+    }
+}
+_a = Oauth2Service;
+_Oauth2Service_implementation = { value: void 0 };
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Oauth2Service.isGetOauthCodeError = (error) => error === 'user-cancelled' ||
+    (typeof error === 'object' &&
+        'code' in error &&
+        Object.values(SocialOAuthErrorCode).includes(error.code) &&
+        'message' in error &&
+        typeof error.message === 'string');
+
+export { Oauth2Service };

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.cjs

@@ -0,0 +1,176 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../_virtual/_tslib.cjs');
+var types = require('@dynamic-labs/types');
+var logger = require('../../../logger/logger.cjs');
+var connectWithAppleId = require('../utils/connectWithAppleId/connectWithAppleId.cjs');
+var isMobile = require('../../../isMobile.cjs');
+
+let authWindowInterval;
+const createWindowOauth2Service = () => ({
+    getOauthCode: ({ apiProvider, provider, redirectUrl, setIsProcessing, state, oauthLoginUrl, initWebAuth, strategy, }) => new Promise((resolve, _reject) => {
+        /**
+         * Use AppleID SDK for Apple provider on mobile
+         * It should use the strategy setting, but on ios or safari
+         * it should use the appleId always as it is the best experience
+         */
+        if (provider === types.ProviderEnum.Apple &&
+            (isMobile.isSafariBrowser() || isMobile.isIOS() || strategy === 'redirect')) {
+            initWebAuth({
+                redirectUrl: redirectUrl || window.location.href,
+            }).then(() => connectWithAppleId.connectWithAppleId({
+                clientId: apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.clientId,
+                oauthLoginUrl,
+                state,
+            }).catch(_reject));
+            return;
+        }
+        /**
+         * Use redirect flow on mobile for all providers except Telegram
+         */
+        if (strategy === 'redirect' && provider !== types.ProviderEnum.Telegram) {
+            initWebAuth({
+                redirectUrl: redirectUrl || window.location.href,
+            }).then(() => {
+                window.location.assign(oauthLoginUrl);
+            });
+            return;
+        }
+        // When we catch this error we assume it follows this type, so we must enforce it
+        // here to ensure the assumption is correct
+        const typedReject = (params) => _reject(params);
+        // Clear any potential pending timeouts and intervals
+        clearInterval(authWindowInterval);
+        const providersWaitingOauthMessage = {};
+        const authWindow = window.open('', '_blank', 'width=500,height=600');
+        const clearListeners = () => {
+            window.removeEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = false;
+        };
+        const handleWindowMessage = (event) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+            const message = event.data;
+            const expectedOrigin = getExpectedOrigin(apiProvider);
+            if (!expectedOrigin) {
+                return;
+            }
+            if ((message === null || message === void 0 ? void 0 : message.type) === 'origin_check' && authWindow) {
+                logger.logger.debug('Origin check message received. Sending response now.', {
+                    data: message,
+                    expectedOrigin,
+                });
+                authWindow.postMessage('origin_check_response', expectedOrigin);
+                return;
+            }
+            const isTelegramCompletedMessage = (message === null || message === void 0 ? void 0 : message.type) === 'telegram_completed';
+            const isAuthorizationMessage = (message === null || message === void 0 ? void 0 : message.type) === 'authorization_response';
+            if (isAuthorizationMessage || isTelegramCompletedMessage) {
+                logger.logger.debug('Message received', { data: message });
+            }
+            const isExpectedOrigin = event.origin === expectedOrigin;
+            const isValidMessage = ((isAuthorizationMessage && (message === null || message === void 0 ? void 0 : message.provider) === provider) ||
+                isTelegramCompletedMessage) &&
+                isExpectedOrigin;
+            // don't process invalid messages for provider
+            if (!isValidMessage) {
+                return;
+            }
+            setIsProcessing(true);
+            if (!providersWaitingOauthMessage[provider]) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.SESSION_TIMEOUT,
+                    message: `Connecting ${provider} account session timeout.`,
+                });
+                return;
+            }
+            clearListeners();
+            if (isTelegramCompletedMessage) {
+                handleTelegramCompletionMessage(message, state);
+                return;
+            }
+            handleAuthorizationMessage(message, provider, state);
+        });
+        const getExpectedOrigin = (apiProvider) => {
+            if (!(apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.redirectUrl)) {
+                return;
+            }
+            try {
+                const redirectUri = new URL(apiProvider.redirectUrl);
+                return redirectUri.origin;
+            }
+            catch (e) {
+                logger.logger.error('Failed to parse social provider redirect url', {
+                    error: e,
+                });
+                return;
+            }
+        };
+        const handleTelegramCompletionMessage = (message, state) => {
+            logger.logger.debug('Telegram completion message received', {
+                data: message,
+            });
+            const { code, state: authState } = message;
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            if (state !== authState) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: 'Failed to connect telegram account: Invalid random state',
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        };
+        const handleAuthorizationMessage = (message, provider, state) => {
+            const { code, error, state: authState } = message;
+            if (error && error !== 'undefined') {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: ${error}`,
+                });
+                return;
+            }
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            // this state check is used only by providers with an open window opener reference (eg, not twitter)
+            if (state !== authState) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: Invalid random state`,
+                });
+                return;
+            }
+            if (!code) {
+                typedReject({
+                    code: types.SocialOAuthErrorCode.NO_AUTH_CODE,
+                    message: `Failed to connect ${provider} social account: no authorization code`,
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        };
+        if (!providersWaitingOauthMessage[provider]) {
+            window.addEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = true;
+        }
+        // First we store the state in backend
+        initWebAuth().then(() => {
+            authWindow === null || authWindow === void 0 ? void 0 : authWindow.location.assign(oauthLoginUrl);
+            authWindowInterval = setInterval(() => {
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed))
+                    return;
+                clearInterval(authWindowInterval);
+                setIsProcessing(false);
+                // user didn't complete oauth
+                if (providersWaitingOauthMessage[provider])
+                    typedReject('user-cancelled');
+            }, 2000);
+        });
+    }),
+});
+
+exports.createWindowOauth2Service = createWindowOauth2Service;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.d.ts

@@ -0,0 +1,2 @@
+import { IOauth2Service } from '../Oauth2Service';
+export declare const createWindowOauth2Service: () => IOauth2Service;

package/src/services/Oauth2Service/createWindowOauth2Service/createWindowOauth2Service.js

@@ -0,0 +1,172 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { ProviderEnum, SocialOAuthErrorCode } from '@dynamic-labs/types';
+import { logger } from '../../../logger/logger.js';
+import { connectWithAppleId } from '../utils/connectWithAppleId/connectWithAppleId.js';
+import { isSafariBrowser, isIOS } from '../../../isMobile.js';
+
+let authWindowInterval;
+const createWindowOauth2Service = () => ({
+    getOauthCode: ({ apiProvider, provider, redirectUrl, setIsProcessing, state, oauthLoginUrl, initWebAuth, strategy, }) => new Promise((resolve, _reject) => {
+        /**
+         * Use AppleID SDK for Apple provider on mobile
+         * It should use the strategy setting, but on ios or safari
+         * it should use the appleId always as it is the best experience
+         */
+        if (provider === ProviderEnum.Apple &&
+            (isSafariBrowser() || isIOS() || strategy === 'redirect')) {
+            initWebAuth({
+                redirectUrl: redirectUrl || window.location.href,
+            }).then(() => connectWithAppleId({
+                clientId: apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.clientId,
+                oauthLoginUrl,
+                state,
+            }).catch(_reject));
+            return;
+        }
+        /**
+         * Use redirect flow on mobile for all providers except Telegram
+         */
+        if (strategy === 'redirect' && provider !== ProviderEnum.Telegram) {
+            initWebAuth({
+                redirectUrl: redirectUrl || window.location.href,
+            }).then(() => {
+                window.location.assign(oauthLoginUrl);
+            });
+            return;
+        }
+        // When we catch this error we assume it follows this type, so we must enforce it
+        // here to ensure the assumption is correct
+        const typedReject = (params) => _reject(params);
+        // Clear any potential pending timeouts and intervals
+        clearInterval(authWindowInterval);
+        const providersWaitingOauthMessage = {};
+        const authWindow = window.open('', '_blank', 'width=500,height=600');
+        const clearListeners = () => {
+            window.removeEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = false;
+        };
+        const handleWindowMessage = (event) => __awaiter(void 0, void 0, void 0, function* () {
+            const message = event.data;
+            const expectedOrigin = getExpectedOrigin(apiProvider);
+            if (!expectedOrigin) {
+                return;
+            }
+            if ((message === null || message === void 0 ? void 0 : message.type) === 'origin_check' && authWindow) {
+                logger.debug('Origin check message received. Sending response now.', {
+                    data: message,
+                    expectedOrigin,
+                });
+                authWindow.postMessage('origin_check_response', expectedOrigin);
+                return;
+            }
+            const isTelegramCompletedMessage = (message === null || message === void 0 ? void 0 : message.type) === 'telegram_completed';
+            const isAuthorizationMessage = (message === null || message === void 0 ? void 0 : message.type) === 'authorization_response';
+            if (isAuthorizationMessage || isTelegramCompletedMessage) {
+                logger.debug('Message received', { data: message });
+            }
+            const isExpectedOrigin = event.origin === expectedOrigin;
+            const isValidMessage = ((isAuthorizationMessage && (message === null || message === void 0 ? void 0 : message.provider) === provider) ||
+                isTelegramCompletedMessage) &&
+                isExpectedOrigin;
+            // don't process invalid messages for provider
+            if (!isValidMessage) {
+                return;
+            }
+            setIsProcessing(true);
+            if (!providersWaitingOauthMessage[provider]) {
+                typedReject({
+                    code: SocialOAuthErrorCode.SESSION_TIMEOUT,
+                    message: `Connecting ${provider} account session timeout.`,
+                });
+                return;
+            }
+            clearListeners();
+            if (isTelegramCompletedMessage) {
+                handleTelegramCompletionMessage(message, state);
+                return;
+            }
+            handleAuthorizationMessage(message, provider, state);
+        });
+        const getExpectedOrigin = (apiProvider) => {
+            if (!(apiProvider === null || apiProvider === void 0 ? void 0 : apiProvider.redirectUrl)) {
+                return;
+            }
+            try {
+                const redirectUri = new URL(apiProvider.redirectUrl);
+                return redirectUri.origin;
+            }
+            catch (e) {
+                logger.error('Failed to parse social provider redirect url', {
+                    error: e,
+                });
+                return;
+            }
+        };
+        const handleTelegramCompletionMessage = (message, state) => {
+            logger.debug('Telegram completion message received', {
+                data: message,
+            });
+            const { code, state: authState } = message;
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            if (state !== authState) {
+                typedReject({
+                    code: SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: 'Failed to connect telegram account: Invalid random state',
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        };
+        const handleAuthorizationMessage = (message, provider, state) => {
+            const { code, error, state: authState } = message;
+            if (error && error !== 'undefined') {
+                typedReject({
+                    code: SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: ${error}`,
+                });
+                return;
+            }
+            // check that the state we receive from message is the same state we calculated earlier
+            // this could be an attack
+            // this state check is used only by providers with an open window opener reference (eg, not twitter)
+            if (state !== authState) {
+                typedReject({
+                    code: SocialOAuthErrorCode.OAUTH_ERROR,
+                    message: `Failed to connect ${provider} social account: Invalid random state`,
+                });
+                return;
+            }
+            if (!code) {
+                typedReject({
+                    code: SocialOAuthErrorCode.NO_AUTH_CODE,
+                    message: `Failed to connect ${provider} social account: no authorization code`,
+                });
+                return;
+            }
+            resolve(code);
+            setIsProcessing(false);
+        };
+        if (!providersWaitingOauthMessage[provider]) {
+            window.addEventListener('message', handleWindowMessage);
+            providersWaitingOauthMessage[provider] = true;
+        }
+        // First we store the state in backend
+        initWebAuth().then(() => {
+            authWindow === null || authWindow === void 0 ? void 0 : authWindow.location.assign(oauthLoginUrl);
+            authWindowInterval = setInterval(() => {
+                if (!(authWindow === null || authWindow === void 0 ? void 0 : authWindow.closed))
+                    return;
+                clearInterval(authWindowInterval);
+                setIsProcessing(false);
+                // user didn't complete oauth
+                if (providersWaitingOauthMessage[provider])
+                    typedReject('user-cancelled');
+            }, 2000);
+        });
+    }),
+});
+
+export { createWindowOauth2Service };

package/src/services/Oauth2Service/createWindowOauth2Service/index.d.ts

@@ -0,0 +1 @@
+export * from './createWindowOauth2Service';

package/src/services/Oauth2Service/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Oauth2Service';
+export * from './createWindowOauth2Service';

package/src/services/Oauth2Service/utils/connectWithAppleId/connectWithAppleId.cjs

@@ -0,0 +1,26 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var loadAppleId = require('../loadAppleId/loadAppleId.cjs');
+
+const connectWithAppleId = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ clientId, oauthLoginUrl, state, }) {
+    yield loadAppleId.loadAppleId();
+    // Because the AppleID is loaded from a script tag, there is not type for it
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    AppleID.auth.init({
+        clientId,
+        redirectURI: oauthLoginUrl.searchParams.get('redirect_uri'),
+        scope: 'name email',
+        state,
+        usePopup: false,
+    });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    AppleID.auth.signIn();
+});
+
+exports.connectWithAppleId = connectWithAppleId;

package/src/services/Oauth2Service/utils/connectWithAppleId/connectWithAppleId.d.ts

@@ -0,0 +1,7 @@
+type ConnectWithAppleIdOptions = {
+    clientId: string | undefined;
+    oauthLoginUrl: URL;
+    state: string;
+};
+export declare const connectWithAppleId: ({ clientId, oauthLoginUrl, state, }: ConnectWithAppleIdOptions) => Promise<void>;
+export {};