react-memory-optimization 0.0.1

package/dist/lib/store/user/entities/avatar/constants.d.ts

@@ -0,0 +1,2 @@
+import { AvatarCollectionType } from './types';
+export declare const AVATAR_COLLECTIONS: AvatarCollectionType[];

package/dist/lib/store/user/entities/avatar/constants.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVATAR_COLLECTIONS = void 0;
+exports.AVATAR_COLLECTIONS = [
+    {
+        name: 'joker',
+        avatars: [
+            {
+                price: 100000,
+                id: 0 /* EAvatarId.JokerTeens */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 1 /* EAvatarId.JokerKids */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 2 /* EAvatarId.JokerSenior */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 3 /* EAvatarId.JokerRealistic */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 4 /* EAvatarId.JokerFunny */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 5 /* EAvatarId.JokerRealisticSerious */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 6 /* EAvatarId.JokerRealisticPessimism */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 7 /* EAvatarId.JokerCartonCrazy */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+        ],
+    },
+    {
+        name: 'sloth',
+        avatars: [
+            {
+                price: 100000,
+                id: 8 /* EAvatarId.SlothCarton */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+            {
+                price: 100000,
+                id: 9 /* EAvatarId.SlothRealistic */,
+                isSpecial: false,
+                isBlocked: true,
+            },
+        ],
+    },
+];

package/dist/lib/store/user/entities/avatar/index.d.ts

@@ -0,0 +1,28 @@
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+import { ObservableEntity } from 'service/observableEntity';
+import { UserServices } from 'store/user/services';
+import { AvatarInfo, AvatarType, BuyAvatarProps } from './types';
+import { FavAvatarInfo } from '../favorites/types';
+export declare class Avatar extends ObservableEntity<undefined> {
+    service: UserServices;
+    _avatarInfo: AvatarInfo | null;
+    constructor(service: UserServices);
+    revalidateAvatarsInfo(availableIds: number[]): {
+        avatars: {
+            isBlocked: boolean;
+            id: number;
+            price: number;
+            isSpecial: boolean;
+        }[];
+        name: string;
+    }[];
+    handleSaveAvatarInfo(avatar: null | FavAvatarInfo): void;
+    handleBuyAvatar(info: BuyAvatarProps): void;
+    handleChangeUserAvatar(avatarInfo: AvatarType | null): void;
+    set avatarInfo(avatarInfo: null | AvatarInfo);
+    get avatarInfo(): null | AvatarInfo;
+    sendUpdateEntity(info: BaseObservableSubscriber & {
+        isAvatar?: boolean;
+        isAvatars?: boolean;
+    }): UpdateData | null;
+}

package/dist/lib/store/user/entities/avatar/types.d.ts

@@ -0,0 +1,30 @@
+export type AvatarInfo = {
+    activeAvatar: number | null;
+    avatars: AvatarCollectionType[];
+};
+export type AvatarType = {
+    id: number;
+    price: number;
+    isBlocked: boolean;
+    isSpecial: boolean;
+};
+export type AvatarCollectionType = {
+    name: string;
+    avatars: AvatarType[];
+};
+export type BuyAvatarProps = {
+    price: number;
+    id: number;
+};
+export declare const enum EAvatarId {
+    JokerTeens = 0,
+    JokerKids = 1,
+    JokerSenior = 2,
+    JokerRealistic = 3,
+    JokerFunny = 4,
+    JokerRealisticSerious = 5,
+    JokerRealisticPessimism = 6,
+    JokerCartonCrazy = 7,
+    SlothCarton = 8,
+    SlothRealistic = 9
+}

package/dist/lib/store/user/entities/avatar/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/user/entities/balance/index.d.ts

@@ -0,0 +1,25 @@
+import { UserServices } from 'store/user/services';
+import { BalanceInfo, BalanceResponse, ObservableSettings } from './types';
+import { Observable } from 'service/observable';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class Balance extends ObservableEntity<undefined> {
+    service: UserServices;
+    observable: Observable;
+    observableSettings: ObservableSettings;
+    balanceInfo: BalanceInfo | null;
+    needToRolled: number;
+    _bonusCoins: number;
+    rolledWithTax: number;
+    constructor(userServices: UserServices);
+    set bonusCoins(coins: number);
+    get bonusCoins(): number;
+    reset(): void;
+    setNeedToRolledValue(needToRolledValue: number): void;
+    setNeedToTaxValue(rolledWithTax: number): void;
+    updateBalance(balance: BalanceResponse): void;
+    private getBalanceInfo;
+    sendUpdateEntity(info: BaseObservableSubscriber & {
+        [key: string]: unknown;
+    }): UpdateData | null;
+}

package/dist/lib/store/user/entities/balance/types.d.ts

@@ -0,0 +1,29 @@
+export type BalanceInfo = {
+    mainBalance: number;
+    bonusBalance: number;
+    casinoBonusBalance: number;
+    bettingPoints: number;
+    availableForCashOut: number;
+    availableForWithdraw: number;
+    commission: number;
+    loyaltyWager: number;
+    successDepositCnt: number;
+    rolledWithTax: number;
+};
+export type BalanceResponse = {
+    bonusBalance: number;
+    empty: number;
+    deposit: number;
+    inGameBalance: number;
+    inGameBonusBalance: number;
+    inGameTotoBalance: number;
+    mainBalance: number;
+    points: number;
+    loyaltyWager: number;
+    successDepositCnt: number;
+};
+export type ObservableSettings = {
+    [uid: string]: {
+        isBalanceInfo: boolean;
+    };
+};

package/dist/lib/store/user/entities/balance/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/user/entities/bonusWheel/constants.d.ts

@@ -0,0 +1 @@
+export declare const WHEEL_CONTENT: number[];

package/dist/lib/store/user/entities/bonusWheel/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WHEEL_CONTENT = void 0;
+exports.WHEEL_CONTENT = [
+    1000, 2000, 3000, 500, 100, 6000, 7000, 80, 0, 10000, 1500, 1900, 100000, 300,
+    1500, 0,
+];

package/dist/lib/store/user/entities/bonusWheel/index.d.ts

@@ -0,0 +1,17 @@
+import { UserServices } from 'store/user/services';
+import { WheelResultInfo } from './types';
+import { ObservableEntity } from 'service/observableEntity';
+export declare class BonusWheel extends ObservableEntity<undefined> {
+    service: UserServices;
+    wheelItems: number[];
+    _wheelInfo: WheelResultInfo | null;
+    constructor(service: UserServices);
+    favoriteUpdates(info: null | WheelResultInfo): void;
+    set wheelInfo(info: WheelResultInfo);
+    get wheelInfo(): WheelResultInfo;
+    getWheelItems(): number[];
+    getWheelResult(): {
+        value: number;
+        result: number;
+    };
+}

package/dist/lib/store/user/entities/bonusWheel/types.d.ts

@@ -0,0 +1,7 @@
+export type WheelResultInfo = {
+    lastSpinTime: null | number;
+    result: {
+        value: number | null;
+        result: number;
+    };
+};

package/dist/lib/store/user/entities/bonusWheel/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/user/entities/daily/index.d.ts

@@ -0,0 +1,20 @@
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+import { ObservableEntity } from 'service/observableEntity';
+import { UserServices } from 'store/user/services';
+import { DailyInfoType } from './types';
+export declare class DailyActivities extends ObservableEntity<undefined> {
+    _tasks: DailyInfoType[];
+    _activeTask: null | DailyInfoType;
+    services: UserServices;
+    constructor(services: UserServices);
+    set tasks(info: DailyInfoType[]);
+    get tasks(): DailyInfoType[];
+    set activeTask(id: string);
+    get activeTask(): DailyInfoType | null;
+    verificationDailyTasks(): void;
+    private getDailyTasks;
+    sendUpdateEntity(d: BaseObservableSubscriber & {
+        [key: string]: unknown;
+        isActiveTask?: boolean;
+    }): UpdateData | null;
+}

package/dist/lib/store/user/entities/daily/types.d.ts

@@ -0,0 +1,21 @@
+export declare const enum EHamsterAction {
+    Farm = 0,
+    Change = 1,
+    Buy = 2
+}
+export type DailyInfoType = {
+    name: string;
+    id: string;
+    prize: number;
+} & ({
+    type: 'LootBox';
+    rules: {
+        stake: 100;
+        times: 3;
+    };
+} | {
+    type: 'Hamster';
+    action: EHamsterAction;
+} | {
+    type: 'Wheel';
+});

package/dist/lib/store/user/entities/daily/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/user/entities/favorites/constants.d.ts

@@ -0,0 +1,2 @@
+import { UserFavoritesEntities } from './types';
+export declare const FAVORITE_BASE_INFO: UserFavoritesEntities;

package/dist/lib/store/user/entities/favorites/constants.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAVORITE_BASE_INFO = void 0;
+const constant_1 = require("../hamster/constant");
+exports.FAVORITE_BASE_INFO = {
+    casino: {
+        providers: {},
+        games: {},
+        searchHistory: {},
+    },
+    betting: {
+        sports: {},
+        events: {},
+        markets: {},
+    },
+    hamster: {
+        lvl: 0 /* EHamsterLevel.Bronze */,
+        energy: constant_1.HAMSTER_LEVELS[0 /* EHamsterLevel.Bronze */].dailyEnergyLimit,
+        lastActionTime: new Date().getTime(),
+        coins: 0,
+        step: 1,
+        hero: null,
+        boost: 1,
+    },
+    avatars: {
+        activeAvatar: null,
+        availableAvatars: [],
+    },
+    wheelInfo: null,
+    clickId: null,
+    bonusCoins: 0,
+};

package/dist/lib/store/user/entities/favorites/index.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from 'service/observable';
+import { UserServices } from 'store/user/services';
+import { UserFavoritesEntities, ObservableSettings, SubscribeFavoriteGameProps, PrepareFavoriteEntitiesForSavingProps, SubscribeFavoriteGamesProps } from './types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class UserFavorites extends ObservableEntity<undefined> {
+    favoritesObservable: Observable;
+    services: UserServices;
+    observableSettings: ObservableSettings;
+    _favorites: UserFavoritesEntities;
+    constructor(services: UserServices);
+    set favorites(favoriteInfo: UserFavoritesEntities);
+    get favorites(): UserFavoritesEntities;
+    handleSaveFavorites(): void;
+    prepareFavoriteEntitiesForSaving(props: PrepareFavoriteEntitiesForSavingProps): void;
+    handleFavoriteParse(userSettings: string): void;
+    subscribeIsFavoriteGame(props: SubscribeFavoriteGameProps): void;
+    subscribeFavoriteGames(props: SubscribeFavoriteGamesProps): void;
+    sendUpdateEntity(updateInfo: BaseObservableSubscriber & {
+        isMobile: boolean;
+        isFavoriteGame?: boolean;
+        isFavoriteGames?: boolean;
+        gameId?: number;
+        isHamsterDependencies?: boolean;
+        isBonusWheelDependencies?: boolean;
+    }): UpdateData | null;
+}

package/dist/lib/store/user/entities/favorites/types.d.ts

@@ -0,0 +1,122 @@
+import { AdaptedGame } from 'store/casino/entities/games/types';
+import { CasinoServices } from 'store/casino/services';
+import { HamsterInfo } from '../hamster/types';
+import { WheelResultInfo } from '../bonusWheel/types';
+import { CasinoCategory } from 'store/casino/entities/categories/types';
+export type ObservableSettings = {
+    [uid: string]: ObservableSettingIsFavoriteGame | ObservableSettingHasFavoriteGames | ObservableSettingFavoriteGames;
+};
+export type ObservableSettingIsFavoriteGame = {
+    isFavoriteGame: boolean;
+    gameId: number;
+    isMobile: boolean;
+};
+type ObservableSettingHasFavoriteGames = {
+    hasFavorites: boolean;
+};
+export type ObservableSettingFavoriteGames = {
+    isFavoriteGames: boolean;
+    isMobile: boolean;
+    casinoServices: CasinoServices;
+};
+export type UserFavoritesEntities = {
+    casino: {
+        providers: {
+            [providerName: string]: true;
+        };
+        games: {
+            [gameId: string]: true;
+        };
+        searchHistory: {
+            '1'?: string;
+            '2'?: string;
+            '3'?: string;
+        };
+    };
+    avatars: FavAvatarInfo;
+    betting: FavoriteBetting;
+    hamster: HamsterInfo;
+    bonusCoins: number;
+    wheelInfo: null | WheelResultInfo;
+    clickId: string | null;
+};
+export type FavAvatarInfo = {
+    activeAvatar: number | null;
+    availableAvatars: number[];
+};
+type FavoriteBetting = {
+    events: FavoriteEvents;
+    sports: FavoriteSports;
+    markets: {
+        [sportId: number]: FavoriteMarket;
+    };
+};
+type FavoriteMarket = {
+    [marketId: number]: boolean;
+};
+type FavoriteEvents = {
+    [eventUid: string]: {
+        isPrematch: boolean;
+    };
+};
+type FavoriteSports = {
+    [sportId: number]: boolean;
+};
+export type PrepareFavoriteEntitiesForSavingProps = PrepareFavoriteEntitiesForGameSavingProps | PrepareFavoriteEntitiesForSearchSavingProps | PrepareFavoriteEntitiesForProviderSavingProps | PrepareFavoriteEntitiesForClickIdSavingProps | PrepareFavoriteEntitiesForHamsterSavingProps | PrepareFavoriteEntitiesForBonusCoinsProps | PrepareFavoriteEntitiesForWheelResultProps | PrepareFavoriteEntitiesForAvatarProps | PrepareFavoriteEntitiesUserAddAvatarProps | PrepareFavoriteEntitiesForBettingSavingProps;
+type PrepareFavoriteEntitiesForWheelResultProps = {
+    isWheel: boolean;
+    wheelResult: WheelResultInfo;
+};
+type PrepareFavoriteEntitiesForAvatarProps = {
+    isUserAvatar: boolean;
+    userAvatar: number | null;
+};
+type PrepareFavoriteEntitiesUserAddAvatarProps = {
+    isUserAddAvailableAvatar: boolean;
+    id: number | null;
+};
+export type PrepareFavoriteEntitiesForGameSavingProps = {
+    isGame: boolean;
+    gameId: number;
+};
+export type PrepareFavoriteEntitiesForBonusCoinsProps = {
+    isBonusCoins: boolean;
+    coins: number;
+};
+export type PrepareFavoriteEntitiesForSearchSavingProps = {
+    isSearch: boolean;
+    searchText: string;
+};
+export type PrepareFavoriteEntitiesForProviderSavingProps = {
+    isProvider: boolean;
+    providerName: string;
+};
+export type PrepareFavoriteEntitiesForClickIdSavingProps = {
+    isClickId: boolean;
+    clickId: string;
+};
+export type PrepareFavoriteEntitiesForBettingSavingProps = {
+    isBetting: boolean;
+    data: any;
+};
+export type PrepareFavoriteEntitiesForHamsterSavingProps = {
+    isHamster: boolean;
+    hamster: HamsterInfo;
+};
+export type SubscribeFavoriteGameProps = {
+    uid: string;
+    isMobile: boolean;
+    gameId: number;
+    callback: (d: {
+        isFavoriteGame: boolean;
+    }) => void;
+};
+export type SubscribeFavoriteGamesProps = {
+    uid: string;
+    isMobile: boolean;
+    callback: (d: AdaptedGame[]) => void;
+};
+export type FavoriteGame = AdaptedGame & {
+    categoryInfo?: null | CasinoCategory;
+};
+export {};

package/dist/lib/store/user/entities/favorites/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/user/entities/hamster/constant.d.ts

@@ -0,0 +1,10 @@
+import { EHamsterLevel, HamsterLevel } from './types';
+export declare const STEP: {
+    0: number;
+    1: number;
+    2: number;
+    3: number;
+};
+export declare const HAMSTER_LEVELS: {
+    [key in EHamsterLevel]: HamsterLevel;
+};

package/dist/lib/store/user/entities/hamster/constant.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HAMSTER_LEVELS = exports.STEP = void 0;
+exports.STEP = {
+    [0 /* EHamsterLevel.Bronze */]: 1,
+    [1 /* EHamsterLevel.Silver */]: 5,
+    [2 /* EHamsterLevel.Gold */]: 500,
+    [3 /* EHamsterLevel.Master */]: 1000,
+};
+exports.HAMSTER_LEVELS = {
+    [0 /* EHamsterLevel.Bronze */]: {
+        level: 0 /* EHamsterLevel.Bronze */,
+        levelName: 'Bronze',
+        minCoins: 0,
+        maxCoins: 799,
+        dailyEnergyLimit: 1000,
+    },
+    [1 /* EHamsterLevel.Silver */]: {
+        level: 1 /* EHamsterLevel.Silver */,
+        levelName: 'Silver',
+        minCoins: 800,
+        maxCoins: 9999,
+        dailyEnergyLimit: 5500,
+    },
+    [2 /* EHamsterLevel.Gold */]: {
+        level: 2 /* EHamsterLevel.Gold */,
+        levelName: 'Gold',
+        minCoins: 10000,
+        maxCoins: 99999,
+        dailyEnergyLimit: 50000,
+    },
+    [3 /* EHamsterLevel.Master */]: {
+        level: 3 /* EHamsterLevel.Master */,
+        levelName: 'Master',
+        minCoins: 1000000,
+        maxCoins: Infinity,
+        dailyEnergyLimit: 500000,
+    },
+};

package/dist/lib/store/user/entities/hamster/index.d.ts

@@ -0,0 +1,21 @@
+import { ObservableEntity } from 'service/observableEntity';
+import { UserServices } from 'store/user/services';
+import { BuyHeroAvatar, EHamsterLevel, HamsterInfo } from './types';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class Hamster extends ObservableEntity<undefined> {
+    services: UserServices;
+    _hamsterInfo: HamsterInfo | null;
+    currentLevel: EHamsterLevel;
+    nextLevel: EHamsterLevel;
+    constructor(services: UserServices);
+    set hamsterInfo(info: HamsterInfo);
+    get hamsterInfo(): HamsterInfo;
+    changeCoins(sellCoins: number, receiveCoins: number): void;
+    findAndSetCurrentLvl(coins: number): void;
+    handleBuyHero(info: BuyHeroAvatar): void;
+    private getDailyEnergyLimit;
+    boostEnergy(): void;
+    sendUpdateEntity(d: BaseObservableSubscriber & {
+        [key: string]: unknown;
+    }): UpdateData;
+}

package/dist/lib/store/user/entities/hamster/types.d.ts

@@ -0,0 +1,28 @@
+export type HamsterInfo = {
+    lvl: EHamsterLevel;
+    energy: number;
+    lastActionTime: number;
+    coins: number;
+    step: number;
+    hero: null | number;
+    boost: number;
+};
+export declare const enum EHamsterLevel {
+    Bronze = 0,
+    Silver = 1,
+    Gold = 2,
+    Master = 3
+}
+export type HamsterLevel = {
+    level: EHamsterLevel;
+    levelName: keyof typeof EHamsterLevel;
+    minCoins: number;
+    maxCoins: number;
+    dailyEnergyLimit: number;
+};
+export type BuyHeroAvatar = {
+    boost: number;
+    id: number;
+    path: string;
+    price: number;
+};

package/dist/lib/store/user/entities/hamster/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/user/entities/lootBox/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const GAME_SETTINGS: {
+    bets: {
+        bet: number;
+        maxWin: number;
+        minWin: number;
+        chance: number;
+    }[];
+};

package/dist/lib/store/user/entities/lootBox/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAME_SETTINGS = void 0;
+const PRESET_BETS = [
+    {
+        bet: 100,
+        maxWin: 1.3,
+        minWin: 0.9,
+        chance: 0.2,
+    },
+    {
+        bet: 1000,
+        maxWin: 1.5,
+        minWin: 0.8,
+        chance: 0.15,
+    },
+    {
+        bet: 10000,
+        maxWin: 1.3,
+        minWin: 0.9,
+        chance: 0.1,
+    },
+];
+exports.GAME_SETTINGS = {
+    bets: PRESET_BETS,
+};

package/dist/lib/store/user/entities/lootBox/index.d.ts

@@ -0,0 +1,39 @@
+import { ObservableEntity } from 'service/observableEntity';
+import { UserServices } from 'store/user/services';
+import { LootBoxGameSettings } from './types';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class LootBox extends ObservableEntity<undefined> {
+    service: UserServices;
+    gameSettings: LootBoxGameSettings;
+    constructor(service: UserServices);
+    spin(amount: number): {
+        isError: boolean;
+        prize: number;
+        isWin: boolean;
+        description: string;
+        isRealMoney?: undefined;
+    } | {
+        isWin: boolean;
+        prize: number;
+        description: string;
+        isRealMoney: boolean;
+        isError?: undefined;
+    } | {
+        isWin: boolean;
+        prize: number;
+        isRealMoney: boolean;
+        isError?: undefined;
+        description?: undefined;
+    } | {
+        prize: number;
+        isWin: boolean;
+        isError?: undefined;
+        description?: undefined;
+        isRealMoney?: undefined;
+    };
+    private getGameResult;
+    sendUpdateEntity(info: BaseObservableSubscriber & {
+        bet?: number;
+        gameSettings?: boolean;
+    }): UpdateData | null;
+}