@wix/sdk 1.5.9 → 1.6.1

package/build/auth/oauth2/OAuthStrategy.js

@@ -0,0 +1,357 @@
+import { createClient } from '../../wixClient.js';
+import { redirects } from '@wix/redirects';
+import { createAccessToken, isTokenExpired } from '../../tokenHelpers.js';
+import { authentication, recovery, verification } from '@wix/identity';
+import { API_URL } from '../../common.js';
+import { LoginState, TokenRole, } from './types.js';
+import { addPostMessageListener, loadFrame } from '../../iframeUtils.js';
+import { EMAIL_EXISTS, INVALID_CAPTCHA, INVALID_PASSWORD, MISSING_CAPTCHA, RESET_PASSWORD, } from './constants.js';
+import { biHeaderGenerator } from '../../bi/biHeaderGenerator.js';
+import { pkceChallenge } from './pkce-challenge.js';
+const moduleWithTokens = { redirects, authentication, recovery, verification };
+export function OAuthStrategy(config) {
+    const _tokens = config.tokens || {
+        accessToken: { value: '', expiresAt: 0 },
+        refreshToken: { value: '', role: TokenRole.NONE },
+    };
+    const setTokens = (tokens) => {
+        _tokens.accessToken = tokens.accessToken;
+        _tokens.refreshToken = tokens.refreshToken;
+    };
+    let _state = {
+        loginState: LoginState.INITIAL,
+    };
+    const getAuthHeaders = async () => {
+        if (!_tokens.accessToken?.value || isTokenExpired(_tokens.accessToken)) {
+            const tokens = await generateVisitorTokens({
+                refreshToken: _tokens.refreshToken,
+            });
+            setTokens(tokens);
+        }
+        return Promise.resolve({
+            headers: { Authorization: _tokens.accessToken.value },
+        });
+    };
+    const wixClientWithTokens = createClient({
+        modules: moduleWithTokens,
+        auth: { getAuthHeaders },
+    });
+    const generateVisitorTokens = async (tokens) => {
+        if (tokens?.accessToken?.value &&
+            tokens?.refreshToken?.value &&
+            !isTokenExpired(tokens.accessToken)) {
+            return tokens;
+        }
+        if (tokens?.refreshToken?.value) {
+            try {
+                const newTokens = await renewToken(tokens.refreshToken);
+                return newTokens;
+            }
+            catch (e) {
+                // just continue and create a visitor one
+            }
+        }
+        const tokensResponse = await fetchTokens({
+            clientId: config.clientId,
+            grantType: 'anonymous',
+        });
+        return {
+            accessToken: createAccessToken(tokensResponse.access_token, tokensResponse.expires_in),
+            refreshToken: {
+                value: tokensResponse.refresh_token,
+                role: TokenRole.VISITOR,
+            },
+        };
+    };
+    const renewToken = async (refreshToken) => {
+        const tokensResponse = await fetchTokens({
+            refreshToken: refreshToken.value,
+            grantType: 'refresh_token',
+        });
+        const accessToken = createAccessToken(tokensResponse.access_token, tokensResponse.expires_in);
+        return {
+            accessToken,
+            refreshToken,
+        };
+    };
+    const generatePKCE = () => {
+        const pkceState = pkceChallenge();
+        return {
+            codeChallenge: pkceState.code_challenge,
+            codeVerifier: pkceState.code_verifier,
+            state: pkceChallenge().code_challenge,
+        };
+    };
+    const generateOAuthData = (redirectUri, originalUri) => {
+        const state = { redirectUri };
+        const pkceState = generatePKCE();
+        return {
+            ...state,
+            originalUri: originalUri ?? '',
+            codeChallenge: pkceState.codeChallenge,
+            codeVerifier: pkceState.codeVerifier,
+            state: pkceChallenge().code_challenge,
+        };
+    };
+    const getAuthorizationUrlWithOptions = async (oauthData, responseMode, prompt, sessionToken) => {
+        const { redirectSession } = await wixClientWithTokens.redirects.createRedirectSession({
+            auth: {
+                authRequest: {
+                    redirectUri: oauthData.redirectUri,
+                    ...(oauthData.redirectUri && {
+                        redirectUri: oauthData.redirectUri,
+                    }),
+                    clientId: config.clientId,
+                    codeChallenge: oauthData.codeChallenge,
+                    codeChallengeMethod: 'S256',
+                    responseMode,
+                    responseType: 'code',
+                    scope: 'offline_access',
+                    state: oauthData.state,
+                    ...(sessionToken && { sessionToken }),
+                },
+                prompt: redirects.Prompt[prompt],
+            },
+        });
+        return { authUrl: redirectSession.fullUrl };
+    };
+    const getAuthUrl = async (oauthData, opts = {
+        prompt: 'login',
+    }) => {
+        return getAuthorizationUrlWithOptions(oauthData, opts.responseMode ?? 'fragment', opts.prompt ?? 'login');
+    };
+    const parseFromUrl = (url, responseMode = 'fragment') => {
+        const parsedUrl = new URL(url ?? window.location.href);
+        const params = responseMode === 'query'
+            ? parsedUrl.searchParams
+            : new URLSearchParams(parsedUrl.hash.substring(1));
+        const code = params.get('code');
+        const state = params.get('state');
+        const error = params.get('error');
+        const errorDescription = params.get('error_description');
+        return { code, state, ...(error && { error, errorDescription }) };
+    };
+    const getMemberTokens = async (code, state, oauthData) => {
+        if (!code || !state) {
+            throw new Error('Missing code or _state');
+        }
+        else if (state !== oauthData.state) {
+            throw new Error('Invalid _state');
+        }
+        try {
+            const tokensResponse = await fetchTokens({
+                clientId: config.clientId,
+                grantType: 'authorization_code',
+                ...(oauthData.redirectUri && { redirectUri: oauthData.redirectUri }),
+                code,
+                codeVerifier: oauthData.codeVerifier,
+            });
+            return {
+                accessToken: createAccessToken(tokensResponse.access_token, tokensResponse.expires_in),
+                refreshToken: {
+                    value: tokensResponse.refresh_token,
+                    role: TokenRole.MEMBER,
+                },
+            };
+        }
+        catch (e) {
+            throw new Error('Failed to get member tokens');
+        }
+    };
+    const logout = async (originalUrl) => {
+        const { redirectSession } = await wixClientWithTokens.redirects.createRedirectSession({
+            logout: { clientId: config.clientId },
+            callbacks: {
+                postFlowUrl: originalUrl,
+            },
+        });
+        _tokens.accessToken = { value: '', expiresAt: 0 };
+        _tokens.refreshToken = { value: '', role: TokenRole.NONE };
+        return { logoutUrl: redirectSession.fullUrl };
+    };
+    const handleState = (response) => {
+        if (response.state === authentication.StateType.SUCCESS) {
+            return {
+                loginState: LoginState.SUCCESS,
+                data: { sessionToken: response.sessionToken },
+            };
+        }
+        else if (response.state === authentication.StateType.REQUIRE_OWNER_APPROVAL) {
+            return {
+                loginState: LoginState.OWNER_APPROVAL_REQUIRED,
+            };
+        }
+        else if (response.state === authentication.StateType.REQUIRE_EMAIL_VERIFICATION) {
+            _state = {
+                loginState: LoginState.EMAIL_VERIFICATION_REQUIRED,
+                data: { stateToken: response.stateToken },
+            };
+            return _state;
+        }
+        return {
+            loginState: LoginState.FAILURE,
+            error: 'Unknown _state',
+        };
+    };
+    const register = async (params) => {
+        try {
+            const res = await wixClientWithTokens.authentication.registerV2({
+                email: params.email,
+            }, {
+                password: params.password,
+                profile: params.profile,
+                ...(params.captchaTokens && {
+                    captchaTokens: [
+                        {
+                            Recaptcha: params.captchaTokens?.recaptchaToken,
+                            InvisibleRecaptcha: params.captchaTokens?.invisibleRecaptchaToken,
+                        },
+                    ],
+                }),
+            });
+            return handleState(res);
+        }
+        catch (e) {
+            const emailValidation = e.details.validationError?.fieldViolations?.find((v) => v.data.type === 'EMAIL');
+            if (emailValidation) {
+                return {
+                    loginState: LoginState.FAILURE,
+                    error: emailValidation.description,
+                    errorCode: 'invalidEmail',
+                };
+            }
+            if (e.details.applicationError?.code === MISSING_CAPTCHA) {
+                return {
+                    loginState: LoginState.FAILURE,
+                    error: e.message,
+                    errorCode: 'missingCaptchaToken',
+                };
+            }
+            if (e.details.applicationError?.code === EMAIL_EXISTS) {
+                return {
+                    loginState: LoginState.FAILURE,
+                    error: e.message,
+                    errorCode: 'emailAlreadyExists',
+                };
+            }
+            if (e.details.applicationError?.code === INVALID_CAPTCHA) {
+                return {
+                    loginState: LoginState.FAILURE,
+                    error: e.message,
+                    errorCode: 'invalidCaptchaToken',
+                };
+            }
+            return {
+                loginState: LoginState.FAILURE,
+                error: e.message,
+            };
+        }
+    };
+    const login = async (params) => {
+        try {
+            const res = await wixClientWithTokens.authentication.loginV2({
+                email: params.email,
+            }, {
+                password: params.password,
+                ...(params.captchaTokens && {
+                    captchaTokens: [
+                        {
+                            Recaptcha: params.captchaTokens?.recaptchaToken,
+                            InvisibleRecaptcha: params.captchaTokens?.invisibleRecaptchaToken,
+                        },
+                    ],
+                }),
+            });
+            return handleState(res);
+        }
+        catch (e) {
+            return {
+                loginState: LoginState.FAILURE,
+                error: e.message,
+                errorCode: e.details.applicationError?.code === MISSING_CAPTCHA
+                    ? 'missingCaptchaToken'
+                    : e.details.applicationError?.code === INVALID_CAPTCHA
+                        ? 'invalidCaptchaToken'
+                        : e.details.applicationError.code === INVALID_PASSWORD
+                            ? 'invalidPassword'
+                            : e.details.applicationError.code === RESET_PASSWORD
+                                ? 'resetPassword'
+                                : 'invalidEmail',
+            };
+        }
+    };
+    const processVerification = async (nextInputs, state) => {
+        const stateToUse = state ?? _state;
+        if (stateToUse.loginState === LoginState.EMAIL_VERIFICATION_REQUIRED) {
+            const code = nextInputs.verificationCode ?? nextInputs.code;
+            const res = await wixClientWithTokens.verification.verifyDuringAuthentication(code, { stateToken: stateToUse.data.stateToken });
+            return handleState(res);
+        }
+        return {
+            loginState: LoginState.FAILURE,
+            error: 'Unknown _state',
+        };
+    };
+    const getMemberTokensForDirectLogin = async (sessionToken) => {
+        const oauthPKCE = generatePKCE();
+        const { authUrl } = await getAuthorizationUrlWithOptions(oauthPKCE, 'web_message', 'none', sessionToken);
+        const iframePromise = addPostMessageListener(oauthPKCE.state);
+        const iframeEl = loadFrame(authUrl);
+        return iframePromise
+            .then((res) => {
+            return getMemberTokens(res.code, res.state, oauthPKCE);
+        })
+            .finally(() => {
+            if (document.body.contains(iframeEl)) {
+                iframeEl.parentElement?.removeChild(iframeEl);
+            }
+        });
+    };
+    const sendPasswordResetEmail = async (email, redirectUri) => {
+        await wixClientWithTokens.recovery.sendRecoveryEmail(email, {
+            redirect: { url: redirectUri, clientId: config.clientId },
+        });
+    };
+    const loggedIn = () => {
+        return _tokens.refreshToken.role === TokenRole.MEMBER;
+    };
+    return {
+        generateVisitorTokens,
+        renewToken,
+        parseFromUrl,
+        getAuthUrl,
+        getMemberTokens,
+        generateOAuthData,
+        getAuthHeaders,
+        setTokens,
+        getTokens: () => _tokens,
+        loggedIn,
+        logout,
+        register,
+        processVerification,
+        login,
+        getMemberTokensForDirectLogin,
+        sendPasswordResetEmail,
+        captchaInvisibleSiteKey: '6LdoPaUfAAAAAJphvHoUoOob7mx0KDlXyXlgrx5v',
+        captchaVisibleSiteKey: '6Ld0J8IcAAAAANyrnxzrRlX1xrrdXsOmsepUYosy',
+    };
+}
+const fetchTokens = async (payload) => {
+    const res = await fetch(`https://${API_URL}/oauth2/token`, {
+        method: 'POST',
+        body: JSON.stringify(payload),
+        headers: {
+            ...biHeaderGenerator({
+                entityFqdn: 'wix.identity.oauth.v1.refresh_token',
+                methodFqn: 'wix.identity.oauth2.v1.Oauth2Ng.Token',
+                packageName: '@wix/sdk',
+            }),
+            'Content-Type': 'application/json',
+        },
+    });
+    if (res.status !== 200) {
+        throw new Error('something went wrong');
+    }
+    const json = await res.json();
+    return json;
+};

package/build/auth/oauth2/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MISSING_CAPTCHA = "-19971";
+export declare const INVALID_CAPTCHA = "-19970";
+export declare const EMAIL_EXISTS = "-19995";
+export declare const INVALID_PASSWORD = "-19976";
+export declare const RESET_PASSWORD = "-19973";

package/build/auth/oauth2/constants.js

@@ -0,0 +1,5 @@
+export const MISSING_CAPTCHA = '-19971';
+export const INVALID_CAPTCHA = '-19970';
+export const EMAIL_EXISTS = '-19995';
+export const INVALID_PASSWORD = '-19976';
+export const RESET_PASSWORD = '-19973';

package/build/auth/oauth2/pkce-challenge.d.ts

@@ -0,0 +1,5 @@
+export declare function pkceChallenge(length?: number): {
+    code_verifier: string;
+    code_challenge: string;
+};
+export declare function generateChallenge(code_verifier: string): string;

package/build/auth/oauth2/pkce-challenge.js

@@ -0,0 +1,33 @@
+import SHA256 from 'crypto-js/sha256.js';
+import encBase64url from 'crypto-js/enc-base64url.js';
+export function pkceChallenge(length) {
+    if (!length) {
+        length = 43;
+    }
+    if (length < 43 || length > 128) {
+        throw new Error(`Expected a length between 43 and 128. Received ${length}.`);
+    }
+    const verifier = generateVerifier(length);
+    const challenge = generateChallenge(verifier);
+    return {
+        code_verifier: verifier,
+        code_challenge: challenge,
+    };
+}
+function generateVerifier(length) {
+    return random(length);
+}
+export function generateChallenge(code_verifier) {
+    return SHA256(code_verifier).toString(encBase64url);
+}
+function random(size) {
+    const mask = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~';
+    let result = '';
+    const randomUints = crypto.getRandomValues(new Uint8Array(size));
+    for (let i = 0; i < size; i++) {
+        // cap the value of the randomIndex to mask.length - 1
+        const randomIndex = randomUints[i] % mask.length;
+        result += mask[randomIndex];
+    }
+    return result;
+}

package/build/auth/oauth2/types.d.ts

@@ -0,0 +1,121 @@
+import { authentication } from '@wix/identity';
+import { AuthenticationStrategy } from '@wix/sdk-types';
+export interface Tokens {
+    accessToken: AccessToken;
+    refreshToken: RefreshToken;
+}
+export interface Token {
+    value: string;
+}
+export interface AccessToken extends Token {
+    expiresAt: number;
+}
+export interface RefreshToken extends Token {
+    role: TokenRole;
+}
+export interface OauthData extends OauthPKCE {
+    originalUri: string;
+    redirectUri: string;
+}
+export interface OauthPKCE {
+    codeVerifier: string;
+    codeChallenge: string;
+    state: string;
+}
+export interface RegisterParams extends LoginParams {
+    profile?: authentication.IdentityProfile;
+}
+export interface LoginParams {
+    email: string;
+    password: string;
+    captchaTokens?: {
+        invisibleRecaptchaToken?: string;
+        recaptchaToken?: string;
+    };
+}
+export interface IOAuthStrategy extends AuthenticationStrategy {
+    generateVisitorTokens(tokens?: {
+        refreshToken?: RefreshToken;
+        accessToken?: AccessToken;
+    }): Promise<Tokens>;
+    renewToken: (refreshToken: RefreshToken) => Promise<Tokens>;
+    setTokens: (tokens: Tokens) => void;
+    getTokens: () => Tokens;
+    generateOAuthData: (redirectUri: string, originalUri?: string) => OauthData;
+    getAuthUrl: (oauthData: OauthData, opts?: {
+        prompt?: 'login' | 'none';
+        responseMode?: 'fragment' | 'web_message' | 'query';
+    }) => Promise<{
+        authUrl: string;
+    }>;
+    getMemberTokens: (code: string, state: string, oauthData: OauthData) => Promise<Tokens>;
+    logout: (originalUrl: string) => Promise<{
+        logoutUrl: string;
+    }>;
+    parseFromUrl: (url?: string, responseMode?: 'query' | 'fragment') => {
+        code: string;
+        state: string;
+        error?: string;
+        errorDescription?: string;
+    };
+    register: (params: RegisterParams) => Promise<StateMachine>;
+    login: (params: LoginParams) => Promise<StateMachine>;
+    processVerification<T extends ProcessableState>(nextInputs: CalculateNextState<T>, state?: StateMachine): Promise<StateMachine>;
+    getMemberTokensForDirectLogin: (sessionToken: string) => Promise<Tokens>;
+    sendPasswordResetEmail: (email: string, redirectUri: string) => Promise<void>;
+    captchaInvisibleSiteKey: string;
+    captchaVisibleSiteKey: string;
+    loggedIn: () => boolean;
+}
+export declare enum LoginState {
+    SUCCESS = "SUCCESS",
+    INITIAL = "INITIAL",
+    FAILURE = "FAILURE",
+    EMAIL_VERIFICATION_REQUIRED = "EMAIL_VERIFICATION_REQUIRED",
+    OWNER_APPROVAL_REQUIRED = "OWNER_APPROVAL_REQUIRED",
+    USER_CAPTCHA_REQUIRED = "USER_CAPTCHA_REQUIRED",
+    SILENT_CAPTCHA_REQUIRED = "SILENT_CAPTCHA_REQUIRED"
+}
+interface LoginResults<LK extends LoginState> {
+    loginState: LK;
+}
+interface SuccessState extends LoginResults<LoginState.SUCCESS> {
+    data: {
+        sessionToken: string;
+    };
+}
+interface InitialState extends LoginResults<LoginState.INITIAL> {
+}
+interface ErrorState extends LoginResults<LoginState.FAILURE> {
+    errorCode?: 'invalidEmail' | 'invalidPassword' | 'resetPassword' | 'missingCaptchaToken' | 'emailAlreadyExists' | 'invalidCaptchaToken';
+    error: string;
+}
+interface EmailVerificationRequiredState extends LoginResults<LoginState.EMAIL_VERIFICATION_REQUIRED> {
+    data: {
+        stateToken: string;
+    };
+}
+interface OwnerApprovalRequiredState extends LoginResults<LoginState.OWNER_APPROVAL_REQUIRED> {
+}
+interface SilentCaptchaRequiredState extends LoginResults<LoginState.SILENT_CAPTCHA_REQUIRED> {
+    data: {
+        stateToken: string;
+    };
+}
+interface UserCaptchaRequiredState extends LoginResults<LoginState.USER_CAPTCHA_REQUIRED> {
+    data: {
+        stateToken: string;
+    };
+}
+export declare enum TokenRole {
+    NONE = "none",
+    VISITOR = "visitor",
+    MEMBER = "member"
+}
+export type StateMachine = InitialState | SuccessState | ErrorState | EmailVerificationRequiredState | OwnerApprovalRequiredState | SilentCaptchaRequiredState | UserCaptchaRequiredState;
+type VerificationCode = {
+    verificationCode: string;
+};
+export type CalculateNextState<T> = T extends EmailVerificationRequiredState ? VerificationCode : never;
+export type ProcessableState = EmailVerificationRequiredState;
+export {};

package/build/auth/oauth2/types.js

@@ -0,0 +1,16 @@
+export var LoginState;
+(function (LoginState) {
+    LoginState["SUCCESS"] = "SUCCESS";
+    LoginState["INITIAL"] = "INITIAL";
+    LoginState["FAILURE"] = "FAILURE";
+    LoginState["EMAIL_VERIFICATION_REQUIRED"] = "EMAIL_VERIFICATION_REQUIRED";
+    LoginState["OWNER_APPROVAL_REQUIRED"] = "OWNER_APPROVAL_REQUIRED";
+    LoginState["USER_CAPTCHA_REQUIRED"] = "USER_CAPTCHA_REQUIRED";
+    LoginState["SILENT_CAPTCHA_REQUIRED"] = "SILENT_CAPTCHA_REQUIRED";
+})(LoginState || (LoginState = {}));
+export var TokenRole;
+(function (TokenRole) {
+    TokenRole["NONE"] = "none";
+    TokenRole["VISITOR"] = "visitor";
+    TokenRole["MEMBER"] = "member";
+})(TokenRole || (TokenRole = {}));

package/build/bi/biHeaderGenerator.d.ts

@@ -0,0 +1,12 @@
+import { APIMetadata } from '@wix/sdk-types';
+import { PublicMetadata } from '../common.js';
+export declare const WixBIHeaderName = "x-wix-bi-gateway";
+export type WixBIHeaderValues = {
+    ['environment']: 'js-sdk';
+    ['package-name']?: string;
+    ['method-fqn']?: string;
+    ['entity']?: string;
+};
+export declare function biHeaderGenerator(apiMetadata: APIMetadata, publicMetadata?: PublicMetadata): {
+    [WixBIHeaderName]: string;
+};

package/build/bi/biHeaderGenerator.js

@@ -0,0 +1,17 @@
+export const WixBIHeaderName = 'x-wix-bi-gateway';
+export function biHeaderGenerator(apiMetadata, publicMetadata) {
+    return {
+        [WixBIHeaderName]: objectToKeyValue({
+            environment: 'js-sdk',
+            'package-name': apiMetadata.packageName ?? publicMetadata?.PACKAGE_NAME,
+            'method-fqn': apiMetadata.methodFqn,
+            entity: apiMetadata.entityFqdn,
+        }),
+    };
+}
+function objectToKeyValue(input) {
+    return Object.entries(input)
+        .filter(([_, value]) => Boolean(value))
+        .map(([key, value]) => `${key}=${value}`)
+        .join(',');
+}

package/build/common.d.ts

@@ -0,0 +1,7 @@
+export declare const PUBLIC_METADATA_KEY = "__metadata";
+export type PublicMetadata = {
+    PACKAGE_NAME?: string;
+};
+export declare const API_URL = "www.wixapis.com";
+export declare const READ_ONLY_API_URL = "readonly.wixapis.com";
+export declare const FORCE_WRITE_API_URLS: string[];

package/build/common.js

@@ -0,0 +1,4 @@
+export const PUBLIC_METADATA_KEY = '__metadata';
+export const API_URL = 'www.wixapis.com';
+export const READ_ONLY_API_URL = 'readonly.wixapis.com';
+export const FORCE_WRITE_API_URLS = ['/ecom/v1/carts/current'];

package/build/fetch-error.d.ts

@@ -0,0 +1,9 @@
+export declare class FetchErrorResponse extends Error {
+    readonly message: string;
+    readonly response: Response;
+    constructor(message: string, response: Response);
+    details(): Promise<{
+        details: any;
+        message: string;
+    }>;
+}

package/build/fetch-error.js

@@ -0,0 +1,31 @@
+export class FetchErrorResponse extends Error {
+    message;
+    response;
+    constructor(message, response) {
+        super(message);
+        this.message = message;
+        this.response = response;
+    }
+    async details() {
+        const dataError = await this.response.json();
+        return errorBuilder(this.response.status, dataError?.message, dataError?.details, {
+            requestId: this.response.headers.get('X-Wix-Request-Id'),
+            details: dataError,
+        });
+    }
+}
+const errorBuilder = (code, description, details, data) => {
+    return {
+        details: {
+            ...(!details?.validationError && {
+                applicationError: {
+                    description,
+                    code,
+                    data,
+                },
+            }),
+            ...details,
+        },
+        message: description,
+    };
+};

package/build/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const getDefaultContentHeader: (options: RequestInit | undefined) => {
+    'Content-Type'?: string;
+};
+export declare const isObject: (val: any) => val is Object;

package/build/helpers.js

@@ -0,0 +1,11 @@
+// we follow a simplified version of the axios convention
+// https://github.com/axios/axios/blob/649d739288c8e2c55829ac60e2345a0f3439c730/lib/defaults/index.js#L65
+export const getDefaultContentHeader = (options) => {
+    if (options?.method &&
+        ['post', 'put', 'patch'].includes(options.method.toLocaleLowerCase()) &&
+        options.body) {
+        return { 'Content-Type': 'application/json' };
+    }
+    return {};
+};
+export const isObject = (val) => val && typeof val === 'object' && !Array.isArray(val);

package/build/host-modules.d.ts

@@ -0,0 +1,3 @@
+import { Host, HostModule } from '@wix/sdk-types';
+export declare const isHostModule: (val: any) => val is HostModule<unknown, Host>;
+export declare function buildHostModule(val: HostModule<unknown, Host>, host: Host): unknown;

package/build/host-modules.js

@@ -0,0 +1,5 @@
+import { isObject } from './helpers.js';
+export const isHostModule = (val) => isObject(val) && val.__type === 'host';
+export function buildHostModule(val, host) {
+    return val.create(host);
+}

package/build/iframeUtils.d.ts

@@ -0,0 +1,4 @@
+export declare function addListener(eventTarget: any, name: string, fn: Function): void;
+export declare function removeListener(eventTarget: any, name: string, fn: Function): void;
+export declare function loadFrame(src: string): HTMLIFrameElement;
+export declare function addPostMessageListener(state: string): Promise<unknown>;