@goodgamestudios/cxf-webshop 6.27.3 → 7.0.0-qa.1

package/src_old/handlers/reducers.ts

@@ -0,0 +1,207 @@
+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

@@ -0,0 +1,143 @@
+/* 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

@@ -0,0 +1,35 @@
+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

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

package/src_old/messages/ShopMessageBus.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,15 @@
+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('-')
+}

package/src_old/preFetch.ts

@@ -0,0 +1,43 @@
+import { DIReader } from './common'
+import { inject } from 'readuz'
+
+type LemonstandConfig = {
+    css: string
+    js: string
+    unreadOfferNotifsCountUrl: string
+}
+
+export type PreFetch = (...parameter: any[]) => void
+
+export const preResolveConfig: DIReader<PreFetch> = inject(
+    (environment) => environment.log,
+    (environment) => environment.setStore,
+    (environment) => environment.createCustomizationUrl,
+    (log, setStore, getCustomizationUrl) => () => {
+        if (typeof fetch !== 'function') {
+            return
+        }
+        const originalCustomUrl = getCustomizationUrl()
+        let resolvedUrl = ''
+        fetch(originalCustomUrl)
+            .then((resp) => {
+                const currentCustomUrl = getCustomizationUrl()
+                if (currentCustomUrl === originalCustomUrl) {
+                    // this is the latest, we keep it
+                    resolvedUrl = resp.url
+                    log('parsed customization url is ' + resolvedUrl)
+                    setStore({
+                        resolvedCustomizationUrl: resolvedUrl,
+                    })
+                    return resp.json()
+                }
+            })
+            .then((config: LemonstandConfig | undefined) => {
+                if (config) {
+                    setStore({
+                        unreadOfferNotifsCountUrl: config.unreadOfferNotifsCountUrl || '',
+                    })
+                }
+            })
+    }
+)

package/src_old/storage.ts

@@ -0,0 +1,32 @@
+import { IDictionary } from './common'
+
+export interface IStorageData {
+    growthFund: {
+        lastPopup: IDictionary<number>
+    }
+}
+
+export type GetStorageData = () => IStorageData
+export const getStorageData: GetStorageData = () => {
+    const restoreData = () => JSON.parse(localStorage.getItem('webshop') as string) as IStorageData
+
+    if (localStorage.getItem('webshop')) {
+        return restoreData()
+    }
+
+    localStorage.setItem(
+        'webshop',
+        JSON.stringify({
+            growthFund: {
+                lastPopup: {},
+            },
+        } as IStorageData)
+    )
+
+    return restoreData()
+}
+
+export type SetStorageData = (data: IStorageData) => void
+export const setStorageData: SetStorageData = (data: IStorageData) => {
+    localStorage.setItem('webshop', JSON.stringify(data))
+}

package/src_old/store.ts

@@ -0,0 +1,82 @@
+import { DIReader, IDictionary } from './common'
+import { inject } from 'readuz'
+import { CountryCode, IGameEvent } from '@goodgamestudios/cxf-events'
+import { ICXF, IGameApi } from './cxf'
+
+export interface IStore {
+    playerId?: string
+    instanceId: string
+    networkId: string
+    gameId: string
+    gameApi: IGameApi
+    language?: string
+    token?: string
+    zoneId?: string
+    xp: number
+    level: number
+    gameEvents: IGameEvent[]
+    countryCode: CountryCode
+    lastPurchaseTab: string
+    legendLevel?: number
+    subscriptionDisabled: boolean
+    isTempServer: boolean
+    customizationSuffix: string
+    resolvedCustomizationUrl?: string
+    sourceId: string
+    unreadOfferNotifsCountUrl: string
+    adStatus?: Record<string, any>
+}
+
+export function defaultStore(cxf: ICXF): IStore {
+    return {
+        playerId: cxf.playerId,
+        instanceId: cxf.instanceId,
+        networkId: cxf.networkId,
+        gameId: cxf.gameId,
+        gameApi: cxf.gameApi,
+        language: cxf.language,
+        token: cxf.token,
+        zoneId: cxf.zoneId,
+        gameEvents: [],
+        xp: 0,
+        level: 0,
+        legendLevel: undefined,
+        countryCode: '',
+        lastPurchaseTab: '',
+        subscriptionDisabled: false,
+        isTempServer: false,
+        customizationSuffix: '',
+        resolvedCustomizationUrl: '',
+        sourceId: 'unknown',
+        unreadOfferNotifsCountUrl: '',
+    }
+}
+
+export type GetStore = () => IStore
+export const getStore: DIReader<GetStore> = inject(
+    (environment) => environment.log,
+    (environment) => environment.store,
+    (log, store) => () => {
+        return store.get() as IStore
+    }
+)
+
+export type SetStore = (data: Partial<IStore>) => void
+export const setStore: DIReader<SetStore> = inject(
+    (environment) => environment.log,
+    (environment) => environment.store,
+    (log, store) => (data) => {
+        const state = store.get() as IStore
+        store.set({
+            ...state,
+            ...data,
+        })
+    }
+)
+
+export function criteriaSelector({ legendLevel, level }: IStore): IDictionary<any> {
+    return {
+        legendLevel,
+        level,
+    }
+}

package/src_old/track.ts

@@ -0,0 +1,59 @@
+import { inject } from 'readuz'
+import { DIReader, IDictionary } from './common'
+import { msToSec } from './utils'
+import { getCxf, getTokenAndLanguage } from './helpers'
+
+export type IRanchWebShopCallProperties = {
+    eventId: number
+    gameId: number
+    playerId: number
+    instanceId: number
+    zoneId: number
+    networkId: number
+    sessionId: string
+    date: number
+    unixtimeMS: number
+    sourceId: string
+}
+
+export type TrackOpenAction = (sid: string) => void
+export const trackOpenAction: DIReader<TrackOpenAction> = inject(
+    (environment) => environment.config,
+    (environment) => environment.trackAction,
+    (environment) => environment.getStore,
+    ({ WEB_SHOP_CALL_TRACK_ID }, trackUserAction, getStore) =>
+        (sid) => {
+            const now = Date.now()
+            const parameters = getTokenAndLanguage(getStore())
+            const { zoneId } = parameters
+            const sessionId = sid
+            const { playerId, gameId, networkId, instanceId, sourceId } = getStore()
+            trackUserAction({
+                eventId: WEB_SHOP_CALL_TRACK_ID,
+                date: msToSec(now),
+                unixtimeMS: now,
+                sessionId,
+                zoneId: zoneId ? Number.parseInt(zoneId, 10) : undefined,
+                playerId: Number.parseInt(playerId as string, 10),
+                gameId: Number.parseInt(gameId, 10),
+                networkId: Number.parseInt(networkId, 10),
+                instanceId: Number.parseInt(instanceId, 10),
+                sourceId,
+            } as IRanchWebShopCallProperties)
+        }
+)
+
+export interface ITrackPayload extends IDictionary<string | number> {
+    eventId: number
+}
+
+export type TrackAction = (payload: ITrackPayload) => void
+export const trackAction: DIReader<TrackAction> = inject(
+    (environment) => environment.config,
+    (environment) => environment.cxfProvider,
+    ({ CXF_TRACK_MSG }, cxfProvider) =>
+        (payload) => {
+            const cxf = getCxf(cxfProvider)
+            cxf.emit(CXF_TRACK_MSG, payload)
+        }
+)