@goodgamestudios/cxf-webshop 7.0.0-qa.2 → 7.0.0-qa.20

package/src_old/fetch.ts

@@ -1,46 +0,0 @@
-import { DIReader } from './common'
-import { inject } from 'readuz'
-import { criteriaSelector } from './store'
-
-export type OfferNotificationsFetchResult = () => void
-export const fetchUnreadOfferNotificationsCount: DIReader<OfferNotificationsFetchResult> = inject(
-    (environment) => environment.log,
-    (environment) => environment.logError,
-    (environment) => environment.getStore,
-    (environment) => environment.config,
-    (log, logError, getStore, { LEGEND_LEVEL_IS_USED }) =>
-        async () => {
-            const store = getStore()
-            if (LEGEND_LEVEL_IS_USED && store.legendLevel === undefined) {
-                log('Skip fetchUnreadOfferNotificationsCount due to legendLevel is undefined')
-                return
-            }
-            log('fetchUnreadOfferNotificationsCount')
-            if (store.token && store.unreadOfferNotifsCountUrl) {
-                let unreadCount = 0
-                const headers = {
-                    Authorization: `Bearer ${store.token}`,
-                }
-                const url = store.unreadOfferNotifsCountUrl
-                    .replace('{locale}', store.language || '')
-                    .replace('{zoneId}', store.zoneId || '')
-                    .replace('{criteria}', encodeURIComponent(JSON.stringify(criteriaSelector(store))))
-                try {
-                    log('fetch', url)
-                    const resp = await fetch(url, {
-                        headers,
-                    })
-                    if (resp.ok) {
-                        const data = await resp.json()
-                        unreadCount = Number(data?.notifCount)
-                    }
-                } catch (error) {
-                    logError(`cannot fetch ${url}`, error)
-                }
-                log('setUnseenOffersCounter', unreadCount)
-                store.gameApi.invokeFn('setUnseenOffersCounter', unreadCount).catch((error) => {
-                    logError('setUnseenOffersCounter error:', error)
-                })
-            }
-        }
-)

package/src_old/handlers/eventHandlers.ts

@@ -1,43 +0,0 @@
-import { inject } from 'readuz'
-import { DIReader } from '../common'
-import { createSessionId } from '../helpers'
-
-export interface OpenIGSPayload {
-    page?: string
-    route?: string
-    sourceId?: string
-    config?: Record<string, any>
-}
-
-export type OnOpen = (payload?: OpenIGSPayload) => void
-export const onOpen: DIReader<OnOpen> = inject(
-    (environment) => environment.createIframeUrl,
-    (environment) => environment.createDialog,
-    (environment) => environment.log,
-    (environment) => environment.trackOpenAction,
-    (environment) => environment.getStore,
-    (environment) => environment.setStore,
-    (createIframeUrl, createDialog, log, trackOpenAction, getStore, setStore) =>
-        (payload = {}) => {
-            log('OnOpen payload:', payload)
-            if (payload.sourceId) {
-                setStore({
-                    sourceId: payload.sourceId,
-                })
-            }
-            const store = getStore()
-            const sid = createSessionId()
-            trackOpenAction(sid)
-            const url = createIframeUrl({
-                sid,
-                page: store.lastPurchaseTab,
-                ...payload,
-            })
-            createDialog(url)
-            setTimeout(() => {
-                // remove unread offer notifications counter on the IGS button while opening the IGS
-                // small delay makes UX a bit better due to it happens after IGS initialization is started
-                store.gameApi.invokeFn('setUnseenOffersCounter', 0)
-            }, 1000)
-        }
-)

package/src_old/handlers/postMessageHandlers.ts

@@ -1,43 +0,0 @@
-import { inject } from 'readuz'
-import { DIReader, WebshopEvents, IDictionary } from '../common'
-import { combineReaders } from '../combineReaders'
-import { createSessionId } from '../helpers'
-
-export type OpenSalesPage = () => void
-export const onSalesPageOpen: DIReader<OpenSalesPage> = inject(
-    (environment) => environment.log,
-    (environment) => environment.createDialog,
-    (environment) => environment.createIframeUrl,
-    (log, createDialog, createIframeUrl) => () => {
-        log('OnOpenSalesOffersPage')
-        const sid = createSessionId()
-        const url = createIframeUrl({
-            page: 'sale-offers',
-            sid,
-        })
-        createDialog(url)
-    }
-)
-
-export type LemonstandClose = () => void
-export const onLemonstandClose: DIReader<LemonstandClose> = inject(
-    (environment) => environment.log,
-    (environment) => environment.getStore,
-    (environment) => environment.fetchUnreadOfferNotificationsCount,
-    (log, getStore, fetchUnreadOfferNotificationsCount) => () => {
-        const store = getStore()
-        log('onLemonstandClose', store)
-        fetchUnreadOfferNotificationsCount()
-    }
-)
-
-export type Handler = (...arguments_: any[]) => void
-export type Handlers = IDictionary<Handler>
-
-export function createPostMessageHandlers(handlers: IDictionary<DIReader<Handler>>) {
-    return combineReaders({
-        [WebshopEvents.CXF_OPEN_SALES_MSG]: onSalesPageOpen,
-        [WebshopEvents.CXF_DIALOG_CLOSE]: onLemonstandClose,
-        ...handlers,
-    })
-}

package/src_old/handlers/pushHandlers.ts

@@ -1,95 +0,0 @@
-import { DIReader, WebshopEvents, IDictionary } from '../common'
-import { combineReaders } from '../combineReaders'
-import { inject } from 'readuz'
-
-interface OnRewardProperties {
-    successUrl: string
-    offerId: string
-    sid: string
-    page: string
-    config?: Record<string, any>
-}
-
-export type OnReward = (properties: OnRewardProperties) => void
-export const onReward: DIReader<OnReward> = inject(
-    (environment) => environment.log,
-    (environment) => environment.createDialog,
-    (environment) => environment.createIframeUrl,
-    (environment) => environment.setStore,
-    (environment) => environment.trackOpenAction,
-    (log, createDialog, createIframeUrl, setStore, trackOpenAction) => (payload) => {
-        log('OnReward: offerId', payload.offerId, 'Page', payload.page)
-        const url = createIframeUrl({
-            route: encodeURIComponent(payload.successUrl),
-            ...payload,
-        })
-        setStore({
-            lastPurchaseTab: payload.page,
-            sourceId: 'successfulPayoutReward',
-        })
-        trackOpenAction(payload.sid)
-
-        createDialog(url)
-    }
-)
-
-export interface OnLemonstandCategoryUpdateProperties {
-    target: string
-    action: string
-    data: any
-}
-export type OnLemonstandCategoryUpdate = (properties: OnLemonstandCategoryUpdateProperties) => void
-export const onLemonstandCategoryUpdate: DIReader<OnLemonstandCategoryUpdate> = inject(
-    (environment) => environment.shopMessageBus,
-    (shopMessageBus) =>
-        ({ target, action, data }) => {
-            shopMessageBus.post({
-                eventName: WebshopEvents.LEMONSTAND_CATEGORY_UPDATE,
-                target,
-                data: { action, data },
-            })
-        }
-)
-
-export interface OnLemonstandNotificationsCreatedProperties {
-    notifCount: number
-}
-type OnLemonstandNotificationsCreated = (properties: OnLemonstandNotificationsCreatedProperties) => void
-
-/**
- * this handler works in case of offer notification activation and deactivation
- */
-export const onLemonstandNotificationsCreated: DIReader<OnLemonstandNotificationsCreated> = inject(
-    (environment) => environment.log,
-    (environment) => environment.logError,
-    (environment) => environment.getStore,
-    (environment) => environment.fetchUnreadOfferNotificationsCount,
-    (log, logError, getStore, fetchUnreadOfferNotificationsCount) =>
-        ({ notifCount }) => {
-            log('onLemonstandNotificationsCreated -> notifCount:', notifCount)
-            const store = getStore()
-            if (notifCount > 0) {
-                // random delay in range 1-120 sec on LIVE, and 1-15 sec on TEST
-                const randomDelayMs = Math.floor(Math.random() * (Number(store.networkId) < 250 ? 120_000 : 15_000))
-                setTimeout(() => {
-                    fetchUnreadOfferNotificationsCount()
-                }, randomDelayMs)
-            } else {
-                store.gameApi.invokeFn('setUnseenOffersCounter', 0).catch((error) => {
-                    logError('setUnseenOffersCounter error:', error)
-                })
-            }
-        }
-)
-
-export type PushHandler = (...arguments_: any[]) => void
-export type PushHandlers = IDictionary<PushHandler>
-
-export function createPushHandlers(handlers: IDictionary<DIReader<PushHandler>>) {
-    return combineReaders({
-        reward: onReward,
-        [WebshopEvents.LEMONSTAND_CATEGORY_UPDATE]: onLemonstandCategoryUpdate,
-        [WebshopEvents.LEMONSTAND_NOTIFICATIONS_CREATED]: onLemonstandNotificationsCreated,
-        ...handlers,
-    })
-}

package/src_old/handlers/reducers.ts

@@ -1,207 +0,0 @@
-import { inject, Reader } from 'readuz'
-import { CxfEvents, IGameEvent, ILoginData } from '@goodgamestudios/cxf-events'
-import { DIReader, WebshopEvents, IDictionary, IPushMessageData } from '../common'
-import { combineReaders } from '../combineReaders'
-
-export type SubscribeToCxf = Reader<void, void>
-const commonCxfReducer: DIReader<SubscribeToCxf> = inject(
-    (environment) => environment.log,
-    (environment) => environment.getCxf,
-    (environment) => environment.onOpen,
-    (environment) => environment.tryCatch,
-    (environment) => environment.pushHandlers,
-    (log, getCxf, onOpen, tryCatch, pushHandlers) => () => {
-        const cxf = getCxf()
-        cxf.on(CxfEvents.OpenIGS, tryCatch(onOpen))
-        cxf.on(
-            CxfEvents.Push,
-            tryCatch(({ id, payload }: IPushMessageData) => {
-                log('cxf.push', id, payload)
-                const handler = pushHandlers[id]
-                handler && handler(payload)
-            })
-        )
-    }
-)
-
-export type CxfReducers = IDictionary<SubscribeToCxf>
-
-export function createCxfReducers(handlers: IDictionary<DIReader<SubscribeToCxf>>) {
-    return combineReaders({
-        common: commonCxfReducer,
-        gameEvents: subscribeToGameEvents,
-        ...handlers,
-    })
-}
-
-export type SubscribeToGameEvents = () => void
-export const subscribeToGameEvents: DIReader<SubscribeToGameEvents> = inject(
-    (environment) => environment.log,
-    (environment) => environment.logError,
-    (environment) => environment.getCxf,
-    (environment) => environment.getStore,
-    (environment) => environment.setStore,
-    (environment) => environment.fetchUnreadOfferNotificationsCount,
-    (log, logError, getCxf, getStore, setStore, fetchUnreadOfferNotificationsCount) => () => {
-        const cxf = getCxf()
-        cxf.on(CxfEvents.Login, (e: ILoginData) => {
-            const { gameEvents } = getStore()
-            const { gameEvents: eventsInLogin } = e
-            // eslint-disable-next-line unicorn/consistent-function-scoping
-            const eventNotExistPredicateGenerator = (existingEvents: IGameEvent[]) => (event: IGameEvent) =>
-                !existingEvents.map((event_) => event_.type).includes(event.type)
-            setStore({
-                ...e,
-                gameEvents: [...gameEvents.filter(eventNotExistPredicateGenerator(eventsInLogin)), ...eventsInLogin],
-            })
-            log(CxfEvents.Login, 'reducer', getStore())
-            fetchUnreadOfferNotificationsCount()
-        })
-
-        cxf.on(CxfEvents.GameEventUpdate, (e: IGameEvent[]) => {
-            log(CxfEvents.GameEventUpdate, e)
-            const store = getStore()
-            const updatedEventTypes = new Set(e.map((event) => event.type))
-            setStore({
-                gameEvents: [...store.gameEvents.filter((event) => !updatedEventTypes.has(event.type)), ...e],
-            })
-            log(CxfEvents.GameEventUpdate, 'reducer', getStore())
-        })
-
-        cxf.on(CxfEvents.GameEventAdd, (e: IGameEvent) => {
-            log(CxfEvents.GameEventAdd, e)
-            const store = getStore()
-            setStore({
-                gameEvents: [...store.gameEvents, e],
-            })
-            log(CxfEvents.GameEventAdd, 'reducer', getStore())
-        })
-
-        cxf.on(CxfEvents.GameEventRemove, (e: number) => {
-            log(CxfEvents.GameEventRemove, e)
-            const store = getStore()
-            setStore({
-                gameEvents: store.gameEvents.filter(({ type }) => type !== e),
-            })
-            log(CxfEvents.GameEventRemove, 'reducer', getStore())
-        })
-
-        cxf.on(CxfEvents.LevelChanged, (level: number) => {
-            log(CxfEvents.LevelChanged, level)
-            setStore({
-                level,
-            })
-            log(CxfEvents.LevelChanged, 'reducer', getStore())
-            fetchUnreadOfferNotificationsCount()
-        })
-
-        cxf.on(CxfEvents.LegendLevelChanged, (legendLevel: number) => {
-            log(CxfEvents.LegendLevelChanged, `legendLevel: ${legendLevel}`)
-            setStore({
-                legendLevel,
-            })
-            const store = getStore()
-            log(CxfEvents.LegendLevelChanged, 'reducer', store)
-            fetchUnreadOfferNotificationsCount()
-        })
-    }
-)
-
-/*
-    In E4K this event is used to control the subscriptions tab
-    This is deprecated, as specific config values/tab visibility can be controlled using Lemonstands `config` query param
-*/
-
-export const nativeSubscriptionEnableReducer: DIReader<SubscribeToCxf> = inject(
-    (environment) => environment.getCxf,
-    (environment) => environment.setStore,
-    (environment) => environment.preResolveConfig,
-    (getCxf, setStore, preResolveConfig) => () => {
-        const cxf = getCxf()
-        cxf.on(WebshopEvents.CXF_NATIVE_SUBSCRIPTION_ENABLE, (enabled: 0 | 1) => {
-            setStore({
-                subscriptionDisabled: enabled === 0,
-                customizationSuffix: enabled === 0 ? 'no-subscription' : '',
-            })
-            preResolveConfig()
-        })
-    }
-)
-
-/*
-    The config file suffix (e.g. "em.json" + "mobile" -> "em-mobile.json") can be set through an event
-    Used by MS and BFW integration pages
-*/
-
-export const setCustomizationSuffixReducer: DIReader<SubscribeToCxf> = inject(
-    (environment) => environment.getCxf,
-    (environment) => environment.getStore,
-    (environment) => environment.setStore,
-    (environment) => environment.preResolveConfig,
-    (getCxf, getStore, setStore, preResolveConfig) => () => {
-        const cxf = getCxf()
-        cxf.on(WebshopEvents.CXF_SET_CUSTOMIZATION_SUFFIX, (suffix: string) => {
-            const store = getStore()
-            if (suffix === store.customizationSuffix) {
-                return
-            }
-            setStore({
-                customizationSuffix: suffix || '',
-            })
-            preResolveConfig()
-        })
-    }
-)
-
-/*
-    Information about whether ads are enabled or not is retrieved externally from `cxf-ad-banners` 
-    and stored to be passed to IGS
-*/
-
-export const receiveAdStatusReducer: DIReader<SubscribeToCxf> = inject(
-    (environment) => environment.getCxf,
-    (environment) => environment.setStore,
-    (environment) => environment.config,
-    (getCxf, setStore, { CXF_AD_STATUS }) =>
-        () => {
-            const cxf = getCxf()
-            cxf.on(CXF_AD_STATUS, ({ areBannersAvailable, bannersDetails }: Record<string, any>) => {
-                setStore({
-                    adStatus: {
-                        areBannersAvailable,
-                        bannersDetails,
-                    },
-                })
-            })
-        }
-)
-
-/*
-    Use a dedicated config variant on temp servers
-*/
-
-export const tempServerContextReducer: DIReader<SubscribeToCxf> = inject(
-    (environment) => environment.getCxf,
-    (environment) => environment.getStore,
-    (environment) => environment.setStore,
-    (environment) => environment.preResolveConfig,
-    (getCxf, getStore, setStore, preResolveConfig) => () => {
-        const cxf = getCxf()
-        cxf.on(WebshopEvents.CXF_JOIN_TEMP_SERVER, (isTemp: 0 | 1) => {
-            const store = getStore()
-            setStore({
-                isTempServer: Boolean(isTemp),
-            })
-
-            // ensure suffix is not already set by the environment, e.g. BFW or MS integration
-            // TODO: fully migrate client detection into `cxf-webshop`
-            if (store.customizationSuffix === '' || store.customizationSuffix === 'temp') {
-                setStore({
-                    customizationSuffix: isTemp ? 'temp' : '',
-                })
-            }
-
-            preResolveConfig()
-        })
-    }
-)

package/src_old/helpers.ts

@@ -1,143 +0,0 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import debug from 'debug'
-import { inject } from 'readuz'
-import { v4 as uuidv4 } from 'uuid'
-import { DIReader, IDictionary } from './common'
-import { parentDomain, timeout } from './utils'
-import { ArgumentNullError } from './ArgumentNullError'
-import { encodePing } from './ping'
-import { IStore } from './store'
-import { ICXF } from './cxf'
-
-export function formatQueryString(object: IDictionary<string | number | undefined | null>) {
-    return Object.entries(object)
-        .filter(([key, value]) => value !== null && value !== undefined)
-        .map(([key, value]) => `${key}=${encodeURIComponent(value as string)}`)
-        .join('&')
-}
-
-export const getTokenAndLanguage = (store: IStore) => {
-    const { playerId, token, zoneId, language } = store
-    if (!playerId) {
-        throw new ArgumentNullError('playerId', playerId)
-    }
-    return {
-        token,
-        zoneId,
-        locale: language,
-        ping: encodePing({ ...store, playerId }),
-    }
-}
-
-export interface IProvider<T> {
-    get: () => T | undefined
-    set: (value: T) => void
-}
-
-export const getCxf = (cxfProvider: IProvider<ICXF>) => {
-    const cxf = cxfProvider.get()
-    if (!cxf) {
-        throw new ArgumentNullError('cxf', cxf)
-    }
-    return cxf
-}
-
-export type GetPing = () => string
-export const getPing: DIReader<GetPing> = inject(
-    (environment) => environment.getStore,
-    (getStore) => () => {
-        const store = getStore()
-        const { playerId } = store
-        if (!playerId) {
-            throw new ArgumentNullError('playerId', playerId)
-        }
-        return encodePing({ ...store, playerId })
-    }
-)
-
-export const entityProvider = <T>(initial?: T): IProvider<T> => {
-    let element = initial
-    return {
-        get: () => element,
-        set: (value) => {
-            element = value
-        },
-    }
-}
-
-export type TryCatch = {
-    <R>(function_: () => R): () => R
-    <P1, R>(function_: (p1: P1) => R): (p1: P1) => R
-    <P1, P2, R>(function_: (p1: P1, p2: P2) => R): (p1: P1, p2: P2) => R
-    <P1, P2, P3, R>(function_: (p1: P1, p2: P2, p3: P3) => R): (p1: P1, p2: P2, p3: P3) => R
-}
-export const tryCatch: DIReader<TryCatch> = inject(
-    (environment) => environment.logError,
-    (environment) => environment.throwCxfError,
-    (logError_, throwAnError) =>
-        (function_: any) =>
-        (...arguments_: any[]) => {
-            try {
-                function_(...arguments_)
-            } catch (error) {
-                logError_(error)
-                throwAnError(error as Error)
-            }
-        }
-)
-
-export type ThrowCxfError = (e: Error) => void
-export const throwCxfError: DIReader<ThrowCxfError> = inject(
-    (environment) => environment.config,
-    (environment) => environment.cxfProvider,
-    ({ CXF_ERROR }, cxfProvider) =>
-        (e) => {
-            const cxf = getCxf(cxfProvider)
-            cxf.emit(CXF_ERROR, e)
-        }
-)
-
-export const isArgumentNullError = (e: Error): e is ArgumentNullError => e.name === 'ArgumentNullError'
-
-export type LoadCxf = (...arguments_: any[]) => Promise<ICXF>
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-export const loadCxf = timeout(() => require('@goodgamestudios/cxf-ready') as Promise<ICXF>, 10_000)
-
-/*
- * To show CXF-WEBSHOP debug messages just run in a browser console
- * localStorage.debug = 'CXF-WEBSHOP:*'
- */
-const logger = debug('CXF-WEBSHOP')
-export type Log = (...arguments_: any[]) => void
-export const log: Log = (argument0: any, ...rest: any[]) => logger(argument0, ...rest)
-
-export type LogError = (...arguments_: any[]) => void
-export const logError: LogError = (...arguments_: any[]) =>
-    // tslint:disable-next-line:no-console
-    console.error('%c CXF-WEBSHOP:', 'background: #ff0000; color: #fff', ...arguments_)
-
-export const createSessionId = () => uuidv4()
-
-export type GetDomain = (referrer: string) => string | undefined
-export const getDomain: DIReader<GetDomain> = inject(
-    (environment) => environment.log,
-    () => (referrer) => {
-        return parentDomain(referrer)
-    }
-)
-
-export type GGSGetQueryParams = () => string
-export const ggsGetQueryParams: DIReader<GGSGetQueryParams> = inject(
-    (environment) => environment.log,
-    (nothing) => () => {
-        return ggsGetQueryParameters()
-    }
-)
-
-export type GGSGetReferrerValue = () => string
-export const ggsGetReferrerValue: DIReader<GGSGetReferrerValue> = inject(
-    (environment) => environment.log,
-    (nothing) => () => {
-        return ggsGetReferrer()
-    }
-)

package/src_old/index.ts

@@ -1,35 +0,0 @@
-import { createEnv as createEnvironment } from './env'
-import { app } from './app'
-import { just } from 'readuz'
-import { entityProvider, log } from './helpers'
-import { defaultStore } from './store'
-import { createConfig } from './config'
-import {
-    createCxfReducers,
-    nativeSubscriptionEnableReducer,
-    setCustomizationSuffixReducer,
-    receiveAdStatusReducer,
-    tempServerContextReducer,
-} from './handlers/reducers'
-import { ICXF } from './cxf'
-
-if (localStorage.getItem('cxf_canvas') === 'enabled') {
-    log('Skip cxf-webshop loading...')
-} else {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires, unicorn/prefer-top-level-await
-    require('@goodgamestudios/cxf-ready').then((cxf: ICXF) => {
-        app(
-            createEnvironment({
-                config: just(createConfig(cxf.gameId)),
-                cxfProvider: just(entityProvider(cxf)),
-                store: just(entityProvider(defaultStore(cxf))),
-                subscribeToCxf: createCxfReducers({
-                    receiveAdStatus: receiveAdStatusReducer,
-                    tempServerContext: tempServerContextReducer,
-                    nativeSubscription: nativeSubscriptionEnableReducer,
-                    setCustomizationSuffix: setCustomizationSuffixReducer,
-                }),
-            })
-        )
-    })
-}

package/src_old/messages/IShopMessageBus.ts

@@ -1,3 +0,0 @@
-export interface IShopMessageBus {
-    post(message: any): void
-}

package/src_old/messages/ShopMessageBus.ts

@@ -1,10 +0,0 @@
-import { IShopMessageBus } from './IShopMessageBus'
-
-export class ShopMessageBus implements IShopMessageBus {
-    public post(message: any) {
-        const element = document.querySelector('#dialog') as HTMLIFrameElement
-        if (element && element.tagName.toLocaleLowerCase() === 'iframe') {
-            element.contentWindow?.postMessage(message, '*')
-        }
-    }
-}

package/src_old/messages/TestShopMessageBus.ts

@@ -1,8 +0,0 @@
-import { IShopMessageBus } from './IShopMessageBus'
-
-export class TestShopMessageBus implements IShopMessageBus {
-    public post(message: any) {
-        /* eslint-disable-next-line prettier/prettier */
-    (window as any).dialogPostMessage = JSON.stringify(message)
-    }
-}

package/src_old/ping.ts

@@ -1,15 +0,0 @@
-export interface PingProperties {
-    gameId: string
-    networkId: string
-    instanceId: string
-    playerId: string
-}
-
-export function decodePing(value: string): PingProperties {
-    const [gameId, networkId, instanceId, playerId] = value.split('-')
-    return { gameId, networkId, instanceId, playerId }
-}
-
-export function encodePing({ gameId, networkId, instanceId, playerId }: PingProperties): string {
-    return [gameId, networkId, instanceId, playerId].join('-')
-}