@accelbyte/sdk 1.1.3 → 1.2.2

package/dist/cjs/node/index.node.js

@@ -0,0 +1,834 @@
+'use strict';
+
+var crypto = require('crypto');
+var axios = require('axios');
+var qs = require('query-string');
+var uuid = require('uuid');
+var zod = require('zod');
+var isEqual = require('lodash/isEqual.js');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var uuid__namespace = /*#__PURE__*/_interopNamespaceDefault(uuid);
+
+/*
+ * Copyright (c) 2018-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+global.crypto = crypto.webcrypto;
+
+var _a$1;
+class SdkDevice {
+}
+_a$1 = SdkDevice;
+SdkDevice.ID_KEY = 'deviceId';
+SdkDevice.TYPE = {
+    MOBILE: 'mobile',
+    DESKTOP: 'desktop'
+};
+SdkDevice.getType = () => {
+    return isMobile() ? SdkDevice.TYPE.MOBILE : SdkDevice.TYPE.DESKTOP;
+};
+SdkDevice.generateUUID = () => {
+    const deviceIdInUUID = uuid__namespace.v4().split('-').join('');
+    localStorage.setItem(SdkDevice.ID_KEY, deviceIdInUUID);
+    return deviceIdInUUID;
+};
+SdkDevice.getDeviceId = () => {
+    return localStorage.getItem(_a$1.ID_KEY) || _a$1.generateUUID();
+};
+/*
+  Bellow function is copied from npm 'is-mobile'
+ */
+const mobileRE = /(android|bb\d+|meego).+mobile|armv7l|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series[46]0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+const tabletRE = /android|ipad|playbook|silk/i;
+const isMobile = (opts) => {
+    if (!opts)
+        opts = {};
+    let ua = opts.ua;
+    if (!ua && typeof navigator !== 'undefined')
+        ua = navigator.userAgent;
+    if (ua && ua.headers && typeof ua.headers['user-agent'] === 'string') {
+        ua = ua.headers['user-agent'];
+    }
+    if (typeof ua !== 'string')
+        return false;
+    let result = mobileRE.test(ua) || (!!opts.tablet && tabletRE.test(ua));
+    if (!result &&
+        opts.tablet &&
+        opts.featureDetect &&
+        navigator &&
+        navigator.maxTouchPoints > 1 &&
+        ua.indexOf('Macintosh') !== -1 &&
+        ua.indexOf('Safari') !== -1) {
+        result = true;
+    }
+    return result;
+};
+
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+const requestInterceptors = new Map();
+const responseInterceptors = new Map();
+const injectRequestInterceptors = (requestInterceptor, errorInterceptor) => {
+    const pair = { interceptor: requestInterceptor, errorInterceptor };
+    const ejectId = axios.interceptors.request.use(requestInterceptor, errorInterceptor);
+    requestInterceptors.set(ejectId, pair);
+    return ejectId;
+};
+const injectResponseInterceptors = (responseInterceptor, errorInterceptor) => {
+    const pair = { interceptor: responseInterceptor, errorInterceptor };
+    const ejectId = axios.interceptors.response.use(responseInterceptor, errorInterceptor);
+    responseInterceptors.set(ejectId, pair);
+    return ejectId;
+};
+const loggerInterceptor = (axiosInstance) => {
+    axiosInstance.interceptors.request.use(config => {
+        // Logger.info(config.method?.toUpperCase(), `${config.url}`)
+        return config;
+    }, error => {
+        return Promise.reject(error);
+    });
+};
+class Network {
+    //
+    static create(...configs) {
+        const axiosInstance = axios.create(Object.assign({
+            paramsSerializer: qs.stringify
+        }, ...configs));
+        Array.from(requestInterceptors).forEach(([_key, interceptorPair]) => {
+            const { interceptor, errorInterceptor } = interceptorPair;
+            axiosInstance.interceptors.request.use(interceptor, errorInterceptor);
+        });
+        Array.from(responseInterceptors).forEach(([_key, interceptorPair]) => {
+            const { interceptor, errorInterceptor } = interceptorPair;
+            axiosInstance.interceptors.response.use(interceptor, errorInterceptor);
+        });
+        loggerInterceptor(axiosInstance);
+        return axiosInstance;
+    }
+    static withBearerToken(accessToken, config) {
+        return Network.create(config || {}, {
+            headers: { Authorization: `Bearer ${accessToken}` }
+        });
+    }
+}
+Network.setDeviceTokenCookie = () => {
+    const deviceId = SdkDevice.getDeviceId();
+    document.cookie = `device_token=${deviceId}; path=/;`;
+};
+Network.removeDeviceTokenCookie = () => {
+    document.cookie = `device_token=; expires=${new Date(0).toUTCString()}`;
+};
+Network.getFormUrlEncodedData = (data) => {
+    const formPayload = new URLSearchParams();
+    const formKeys = Object.keys(data);
+    formKeys.forEach(key => {
+        if (data[key])
+            formPayload.append(key, data[key]);
+    });
+    return formPayload;
+};
+
+const ERROR_ELIGIBILITY_CODE = 13130;
+const injectErrorInterceptors = (baseUrl, onUserEligibilityChange, onError) => {
+    injectResponseInterceptors(response => {
+        return response;
+    }, (error) => {
+        if (error.response) {
+            const { response } = error;
+            if (response?.status === 403 && response?.config.url.includes(baseUrl) && response?.config.withCredentials) {
+                if (response.data.errorCode === ERROR_ELIGIBILITY_CODE && onUserEligibilityChange) {
+                    onUserEligibilityChange();
+                }
+            }
+        }
+        if (onError) {
+            onError(error);
+        }
+        throw error;
+    });
+};
+
+/*
+ * Copyright (c) 2022 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class BrowserHelper {
+}
+BrowserHelper.isOnBrowser = () => {
+    return typeof window !== 'undefined' && window.document;
+};
+
+class RefreshSession {
+}
+// --
+RefreshSession.KEY = 'RefreshSession.lock';
+RefreshSession.isLocked = () => {
+    if (!BrowserHelper.isOnBrowser())
+        return false;
+    const lockStatus = localStorage.getItem(RefreshSession.KEY);
+    if (!lockStatus) {
+        return false;
+    }
+    const lockExpiry = Number(lockStatus);
+    if (isNaN(lockExpiry)) {
+        return false;
+    }
+    return lockExpiry > new Date().getTime();
+};
+RefreshSession.lock = (expiry) => {
+    if (!BrowserHelper.isOnBrowser())
+        return;
+    localStorage.setItem(RefreshSession.KEY, `${new Date().getTime() + expiry}`);
+};
+RefreshSession.unlock = () => {
+    if (!BrowserHelper.isOnBrowser())
+        return;
+    localStorage.removeItem(RefreshSession.KEY);
+};
+RefreshSession.sleepAsync = (timeInMs) => new Promise(resolve => setTimeout(resolve, timeInMs));
+RefreshSession.isBearerAuth = (config) => {
+    // @ts-ignore
+    if (config?.headers?.Authorization?.toLowerCase().indexOf('bearer') > -1) {
+        return true;
+    }
+    return false;
+};
+
+/*
+ * Copyright (c) 2022 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class CodeGenUtil {
+    /**
+     * Returns a hash code from a string
+     * @param  {String} str The string to hash.
+     * @return {Number} A 32bit integer
+     * @see http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
+     */
+    static hashCode(str) {
+        let hash = 0;
+        for (let i = 0, len = str.length; i < len; i++) {
+            const chr = str.charCodeAt(i);
+            hash = (hash << 5) - hash + chr;
+            hash |= 0; // Convert to 32bit integer
+        }
+        return hash;
+    }
+}
+CodeGenUtil.getFormUrlEncodedData = (data) => {
+    const formPayload = new URLSearchParams();
+    const formKeys = Object.keys(data);
+    formKeys.forEach(key => {
+        if (typeof data[key] !== 'undefined')
+            formPayload.append(key, data[key]);
+    });
+    return formPayload;
+};
+
+/*
+ * Copyright (c) 2022 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+// TODO replace with Winston
+class Logger {
+    static info(message, object = '') {
+        _log('info:', message, object);
+    }
+    static warn(message, object = '') {
+        _log('warn:', message, object);
+    }
+    static error(message, object = '') {
+        _log('error:', message, object);
+    }
+}
+const _log = (type, message = '', object = '') => {
+    if (type === 'error:') {
+        console.error('\x1b[31m%s\x1b[0m', type, message, object);
+    }
+    else {
+        console.log('\x1b[34m%s\x1b[0m', type, message, object); // blue
+    }
+};
+
+class Validate {
+    //
+    static responseType(networkCall, Codec, modelName) {
+        return wrapNetworkCallSafely(async () => {
+            const response = await networkCall();
+            const decodeResult = Codec.safeParse(response.data);
+            if (!decodeResult.success) {
+                throw new DecodeError({ error: decodeResult.error, response, modelName });
+            }
+            return response;
+        });
+    }
+    static safeParse(data, Codec) {
+        const result = Codec.safeParse(data);
+        if (result.success) {
+            return result.data;
+        }
+        return null;
+    }
+}
+async function wrapNetworkCallSafely(networkCallFunction) {
+    try {
+        const response = await networkCallFunction();
+        // Cleanup so we avoid polluting the response
+        // @ts-ignore
+        delete response.headers; // perhaps this may be required?
+        // @ts-ignore
+        delete response.statusText;
+        // @ts-ignore
+        delete response.config; // axios specific
+        delete response.request;
+        return { response, error: null };
+    }
+    catch (error) {
+        return { response: null, error: error };
+    }
+}
+class DecodeError extends Error {
+    constructor({ error, response, modelName }) {
+        const msg = `response from url "${response.config.url}" doesn't match model "${modelName}"`;
+        super(msg);
+        Logger.error(msg, error);
+    }
+}
+
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+const NamespaceRole = zod.z.object({ namespace: zod.z.string(), roleId: zod.z.string() });
+const PermissionV3 = zod.z.object({
+    action: zod.z.number().int(),
+    resource: zod.z.string(),
+    schedAction: zod.z.number().int().nullish(),
+    schedCron: zod.z.string().nullish(),
+    schedRange: zod.z.array(zod.z.string()).nullish()
+});
+const JwtBanV3 = zod.z.object({
+    ban: zod.z.string(),
+    disabledDate: zod.z.string().nullish(),
+    enabled: zod.z.boolean(),
+    endDate: zod.z.string(),
+    targetedNamespace: zod.z.string()
+});
+const TokenWithDeviceCookieResponseV3 = zod.z.object({
+    access_token: zod.z.string(),
+    auth_trust_id: zod.z.string().nullish(),
+    bans: zod.z.array(JwtBanV3).nullish(),
+    display_name: zod.z.string().nullish(),
+    expires_in: zod.z.number().int(),
+    is_comply: zod.z.boolean().nullish(),
+    jflgs: zod.z.number().int().nullish(),
+    namespace: zod.z.string(),
+    namespace_roles: zod.z.array(NamespaceRole).nullish(),
+    permissions: zod.z.array(PermissionV3),
+    platform_id: zod.z.string().nullish(),
+    platform_user_id: zod.z.string().nullish(),
+    refresh_expires_in: zod.z.number().int().nullish(),
+    refresh_token: zod.z.string().nullish(),
+    roles: zod.z.array(zod.z.string()).nullish(),
+    scope: zod.z.string(),
+    token_type: zod.z.string(),
+    user_id: zod.z.string().nullish(),
+    xuid: zod.z.string().nullish()
+});
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class OAuth20$ {
+    // @ts-ignore
+    constructor(axiosInstance, namespace, cache = false) {
+        this.axiosInstance = axiosInstance;
+        this.namespace = namespace;
+        this.cache = cache;
+    }
+    postOauthToken(data) {
+        const params = {};
+        const url = '/iam/v3/oauth/token';
+        const resultPromise = this.axiosInstance.post(url, CodeGenUtil.getFormUrlEncodedData(data), {
+            ...params,
+            headers: { ...params.headers, 'content-type': 'application/x-www-form-urlencoded' }
+        });
+        return Validate.responseType(() => resultPromise, TokenWithDeviceCookieResponseV3, 'TokenWithDeviceCookieResponseV3');
+    }
+}
+
+/*
+ * Copyright (c) 2022 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class DesktopChecker {
+    static isDesktopApp() {
+        return DesktopChecker.desktopApp && !DesktopChecker.isInIframe();
+    }
+    static isInIframe() {
+        try {
+            return window.self !== window.top;
+        }
+        catch (error) {
+            return true;
+        }
+    }
+    // borrowed from https://github.com/cheton/is-electron
+    static isElectron() {
+        // @ts-ignore Renderer process
+        if (typeof window !== 'undefined' && typeof window.process === 'object' && window.process.type === 'renderer') {
+            return true;
+        }
+        // Main process
+        if (typeof process !== 'undefined' && typeof process.versions === 'object' && !!process.versions.electron) {
+            return true;
+        }
+        // Detect the user agent when the `nodeIntegration` option is set to false
+        if (typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent.indexOf('Electron') >= 0) {
+            return true;
+        }
+        return false;
+    }
+}
+DesktopChecker.desktopApp = DesktopChecker.isElectron();
+
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+const REFRESH_EXPIRY = 1000;
+const REFRESH_EXPIRY_UPDATE_RATE = 500;
+const REFRESH_EXPIRY_CHECK_RATE = 1000;
+var LoginUrls;
+(function (LoginUrls) {
+    LoginUrls["REFRESH_SESSION"] = "/iam/v3/oauth/token";
+    LoginUrls["LOGOUT"] = "/iam/v3/logout";
+    LoginUrls["REVOKE"] = "/iam/v3/oauth/revoke";
+})(LoginUrls || (LoginUrls = {}));
+/* eslint camelcase: 0 */
+const refreshSession = ({ axiosConfig, refreshToken, clientId }) => {
+    const config = {
+        ...axiosConfig,
+        withCredentials: false,
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: `Basic ${Buffer.from(`${clientId}:`).toString('base64')}`
+        }
+    };
+    const axios = Network.create(config);
+    const payload = {
+        refresh_token: refreshToken || undefined,
+        client_id: clientId,
+        grant_type: 'refresh_token'
+    };
+    const oauth20 = new OAuth20$(axios, 'NAMESPACE-NOT-REQUIRED', false);
+    return oauth20.postOauthToken(payload);
+};
+// Return Promise<true> if refresh in any tab is successful;
+const refreshWithLock = ({ axiosConfig, refreshToken, clientId }) => {
+    //
+    if (RefreshSession.isLocked()) {
+        return Promise.resolve().then(async () => {
+            // This block is executed when other tab / request is refreshing
+            while (RefreshSession.isLocked()) {
+                await RefreshSession.sleepAsync(REFRESH_EXPIRY_CHECK_RATE);
+            }
+            return {};
+        });
+    }
+    RefreshSession.lock(REFRESH_EXPIRY);
+    let isLocallyRefreshingToken = true;
+    (async () => {
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (isLocallyRefreshingToken) {
+            RefreshSession.lock(REFRESH_EXPIRY);
+            await RefreshSession.sleepAsync(REFRESH_EXPIRY_UPDATE_RATE);
+        }
+    })();
+    return Promise.resolve()
+        .then(doRefreshSession({ axiosConfig, clientId, refreshToken }))
+        .finally(() => {
+        isLocallyRefreshingToken = false;
+        RefreshSession.unlock();
+    });
+};
+const doRefreshSession = ({ axiosConfig, clientId, refreshToken }) => async () => {
+    // we need this to check if app use “withCredentials: false” and don’t have refreshToken it should return false,
+    // because we track it as a logout user, if not do this even user logout on the desktop app (that use withCredentials: false)
+    // will automatically login with refreshSession
+    if (DesktopChecker.isDesktopApp() && !axiosConfig.withCredentials && !refreshToken) {
+        return false;
+    }
+    const result = await refreshSession({ axiosConfig, clientId, refreshToken });
+    if (result.error) {
+        return false;
+    }
+    return result.response.data;
+};
+const injectAuthInterceptors = (clientId, getSDKConfig, onSessionExpired, onGetUserSession, getRefreshToken) => {
+    // ===== request
+    injectRequestInterceptors(async (config) => {
+        // need to lock on the desktop as well to sleep other request before refresh session is done
+        const isRefreshTokenUrl = config.url === LoginUrls.REFRESH_SESSION;
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (RefreshSession.isLocked() && !isRefreshTokenUrl) {
+            await RefreshSession.sleepAsync(200);
+        }
+        return config;
+    }, (error) => {
+        return Promise.reject(error);
+    });
+    // ===== response
+    injectResponseInterceptors(response => {
+        return response;
+    }, async (error) => {
+        if (axios.isCancel(error)) {
+            // expected case, exit
+            throw error;
+        }
+        else {
+            const { config, response } = error;
+            if (!response) {
+                console.error('injectResponseInterceptors net::ERR_INTERNET_DISCONNECTED');
+            }
+            if (response?.status === 401) {
+                const { url } = config;
+                const axiosConfig = getSDKConfig();
+                const refreshToken = getRefreshToken ? getRefreshToken() : undefined;
+                // expected business case, exit
+                // @ts-ignore
+                if (Object.values(LoginUrls).includes(url)) {
+                    throw error;
+                }
+                // need to lock on the desktop as well to prevent multiple token request
+                return refreshWithLock({ axiosConfig, clientId, refreshToken }).then(tokenResponse => {
+                    return uponRefreshComplete(error, tokenResponse, onGetUserSession, onSessionExpired, axiosConfig, config);
+                });
+            }
+        }
+        return Promise.reject(error);
+    });
+};
+const uponRefreshComplete = (error, tokenResponse, onGetUserSession, onSessionExpired, axiosConfig, errorConfig) => {
+    //
+    if (tokenResponse) {
+        const { access_token, refresh_token } = tokenResponse;
+        if (onGetUserSession && access_token && refresh_token) {
+            onGetUserSession(access_token, refresh_token);
+        }
+        // desktop
+        if (!axiosConfig.withCredentials && access_token) {
+            return axios({
+                ...errorConfig,
+                headers: {
+                    ...errorConfig.headers,
+                    Authorization: `Bearer ${access_token}`
+                }
+            });
+            // web
+        }
+        else {
+            return axios(errorConfig);
+        }
+    }
+    if (onSessionExpired) {
+        console.log('session expired auth');
+        onSessionExpired();
+    }
+    throw error;
+};
+
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class ApiUtils {
+}
+ApiUtils.mergedConfigs = (config, overrides) => {
+    return {
+        ...config,
+        ...overrides?.config,
+        headers: {
+            ...config.headers,
+            ...overrides?.config?.headers
+        }
+    };
+};
+
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class AccelbyteSDKImpl {
+    constructor(options, config, events) {
+        this.getRefreshToken = () => this.refreshToken;
+        this.getConfig = () => this.config;
+        this.refreshTokensImpl = (accessToken, refreshToken) => {
+            if (refreshToken) {
+                this.refreshToken = refreshToken;
+            }
+            const configOverride = { headers: { Authorization: accessToken ? `Bearer ${accessToken}` : '' } };
+            this.config = ApiUtils.mergedConfigs(this.config, { config: configOverride });
+        };
+        this.options = {
+            cache: false,
+            ...options
+        };
+        this.events = events;
+        this.config = {
+            timeout: 60000,
+            baseURL: options.baseURL,
+            withCredentials: true,
+            ...config,
+            headers: {
+                'Content-Type': 'application/json',
+                ...config?.headers
+            }
+        };
+    }
+    init() {
+        const { baseURL, clientId } = this.options;
+        injectAuthInterceptors(clientId, this.getConfig, this.events?.onSessionExpired, this.events?.onGetUserSession, this.getRefreshToken);
+        injectErrorInterceptors(baseURL, this.events?.onUserEligibilityChange, this.events?.onError);
+        // TODO reintegrate doVersionDiagnostics later on
+        // setTimeout(() => this.doVersionDiagnostics(), TIMEOUT_TO_DIAGNOSTICS)
+        return {
+            refreshTokens: (accessToken, refreshToken) => this.refreshTokensImpl(accessToken, refreshToken),
+            assembly: () => {
+                return {
+                    config: this.config,
+                    namespace: this.options.namespace,
+                    clientId: this.options.clientId,
+                    redirectURI: this.options.redirectURI,
+                    baseURL: this.options.baseURL,
+                    cache: this.options.cache !== undefined ? this.options.cache : false
+                };
+            }
+        };
+    }
+}
+const sdkInit = ({ options, config, onEvents }) => {
+    const sdkFactory = new AccelbyteSDKImpl(options, config, onEvents);
+    return sdkFactory.init();
+};
+// ts-prune-ignore-next
+const Accelbyte = { SDK: sdkInit };
+
+/*
+ * Copyright (c) 2022 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+// ts-prune-ignore-next
+const VALIDATION_ERROR_CODE = 20002;
+
+/*
+ * Copyright (c) 2022-2023 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+const ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT = 10200;
+const ERROR_CODE_LINK_DELETION_ACCOUNT = 10135;
+const ERROR_CODE_TOKEN_EXPIRED = 10196;
+const ERROR_USER_BANNED = 10134;
+
+/*
+ * Copyright (c) 2022 AccelByte Inc. All Rights Reserved
+ * This is licensed software from AccelByte Inc, for limitations
+ * and restrictions contact your company contract manager.
+ */
+class UrlHelper {
+    static trimSlashFromStringEnd(pathString) {
+        let newString = pathString;
+        while (newString[newString.length - 1] === '/') {
+            newString = newString.slice(0, -1);
+        }
+        return newString;
+    }
+    static trimSlashFromStringStart(pathString) {
+        let newString = pathString;
+        while (newString[0] === '/') {
+            newString = newString.slice(1);
+        }
+        return newString;
+    }
+    static trimSlashFromStringEdges(pathString) {
+        return UrlHelper.trimSlashFromStringStart(this.trimSlashFromStringEnd(pathString));
+    }
+    static combinePaths(...paths) {
+        const completePath = paths.join('/');
+        // Replace 2 or more consecutive slashes with a single slash.
+        // This is also the behavior from Node's `path.join`.
+        return completePath.replace(/\/{2,}/g, '/');
+    }
+    static combineURLPaths(urlString, ...paths) {
+        const url = new URL(urlString);
+        const { origin } = url;
+        const pathname = UrlHelper.trimSlashFromStringEdges(UrlHelper.combinePaths(url.pathname, ...paths));
+        return new URL(pathname, origin).toString();
+    }
+}
+UrlHelper.isCompleteURLString = (urlString) => {
+    try {
+        const url = new URL(urlString);
+        return url.hostname !== '';
+    }
+    catch (error) { }
+    return false;
+};
+
+var _a;
+class SdkCache {
+    static async withoutCache(apiCall) {
+        // Intercept the call and add onSync callback so that even though cache is false, the client cn still safely attach onSync
+        let apiResponse;
+        let apiError;
+        try {
+            apiResponse = await apiCall();
+            if (apiResponse.error)
+                throw apiResponse.error;
+        }
+        catch (e) {
+            apiError = e;
+        }
+        return new Promise((resolve, reject) => {
+            // const result = apiCall()
+            // resolve && resolve(result.then())
+            // reject && reject(result.catch())
+            const success = {
+                response: apiResponse?.response,
+                error: apiError,
+                onSync: _syncedData => {
+                    // Add empty implementation so client onSync call does not fail with undefined 'onSync' function
+                }
+            };
+            resolve && resolve(success);
+            reject && reject(apiError || apiResponse.error);
+        });
+    }
+    static async withCache(key, apiCall) {
+        let syncObserver;
+        const cacheData = this.cacheStrategy.get(key);
+        if (!cacheData) {
+            const res = await apiCall();
+            const data = res.response?.data;
+            const error = res.error;
+            if (error) {
+                return {
+                    response: res.response,
+                    error,
+                    onSync: func => (syncObserver = func)
+                };
+            }
+            const skipNon200FromCaching = res.response?.status !== 200;
+            if (skipNon200FromCaching) {
+                return {
+                    response: res.response,
+                    error: null,
+                    onSync: func => (syncObserver = func)
+                };
+            }
+            if (data) {
+                this.cacheStrategy.set(key, data);
+            }
+            return {
+                response: { data, status: 200 },
+                error,
+                onSync: func => (syncObserver = func)
+            };
+        }
+        const onSyncCall = async () => {
+            const onSyncResponse = await apiCall();
+            if (onSyncResponse.error) {
+                const res = {
+                    response: null,
+                    error: onSyncResponse.error
+                };
+                syncObserver && syncObserver(res);
+                return res;
+            }
+            const newData = onSyncResponse.response?.data;
+            if (!isEqual(this.cacheStrategy.get(key), newData)) {
+                this.cacheStrategy.set(key, newData);
+                const res = {
+                    response: { data: newData, status: 200 },
+                    error: null
+                };
+                syncObserver && syncObserver(res);
+                return res;
+            }
+            const res = {
+                response: null,
+                error: null
+            };
+            return res;
+        };
+        Promise.resolve().then(onSyncCall);
+        return {
+            response: { data: cacheData, status: 200 },
+            error: null,
+            onSync: observer => (syncObserver = observer)
+        };
+    }
+}
+_a = SdkCache;
+// this could be localStorage or indexeddb
+SdkCache.cacheStrategy = new Map();
+SdkCache.clearCache = () => {
+    _a.cacheStrategy.clear();
+};
+
+exports.Accelbyte = Accelbyte;
+exports.ApiUtils = ApiUtils;
+exports.BrowserHelper = BrowserHelper;
+exports.CodeGenUtil = CodeGenUtil;
+exports.DecodeError = DecodeError;
+exports.DesktopChecker = DesktopChecker;
+exports.ERROR_CODE_LINK_DELETION_ACCOUNT = ERROR_CODE_LINK_DELETION_ACCOUNT;
+exports.ERROR_CODE_TOKEN_EXPIRED = ERROR_CODE_TOKEN_EXPIRED;
+exports.ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT = ERROR_LINK_ANOTHER_3RD_PARTY_ACCOUNT;
+exports.ERROR_USER_BANNED = ERROR_USER_BANNED;
+exports.Network = Network;
+exports.RefreshSession = RefreshSession;
+exports.SdkCache = SdkCache;
+exports.SdkDevice = SdkDevice;
+exports.UrlHelper = UrlHelper;
+exports.VALIDATION_ERROR_CODE = VALIDATION_ERROR_CODE;
+exports.Validate = Validate;
+exports.doRefreshSession = doRefreshSession;
+exports.injectAuthInterceptors = injectAuthInterceptors;
+exports.injectErrorInterceptors = injectErrorInterceptors;
+exports.injectRequestInterceptors = injectRequestInterceptors;
+exports.injectResponseInterceptors = injectResponseInterceptors;
+exports.refreshWithLock = refreshWithLock;
+//# sourceMappingURL=index.node.js.map