react-memory-optimization 0.0.1

package/dist/lib/store/betting/services/index.d.ts

@@ -0,0 +1,311 @@
+import { Betting } from '..';
+import { Bet, ECustomBetUid, EPlaceBetStatus, ExpressBet, SystemBet } from '../entities/betslip/types';
+import { LiveEvent } from '../entities/events/live/types';
+import { PrematchEvent } from '../entities/events/prematch/types';
+import { EventLine } from '../entities/events/types';
+import { PageMarketInfo } from '../entities/markets/types';
+import { Tournament } from '../entities/tournaments/types';
+import { GetBetSlipLimitProps, GetOddProps, ReturnGetMarketsByComboMarketIdProps, ReturnGetOddType } from './types';
+import { ResponseAdapterService } from 'service/responseAdapter/services';
+import { ENotifications } from 'store/notifications/types';
+export declare class BettingServices {
+    parent: Betting;
+    adapterService: ResponseAdapterService;
+    constructor(betting: Betting, adapterService: ResponseAdapterService);
+    sendErrorCommand(code: ENotifications, data: {
+        description?: string;
+    }): void;
+    updateEvent(currentEvent: PrematchEvent | LiveEvent, eventUpdate: PrematchEvent | LiveEvent): {
+        lines: {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        };
+        linesByMarketId: {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        };
+        objectId: number;
+        uid: string;
+        awayId: number;
+        awayName: string;
+        blockedStatus: number;
+        willBeLive: number;
+        categoryId: number;
+        gbId: number;
+        homeId: number;
+        homeName: string;
+        lineTypeRadar: number;
+        counterLines: number;
+        radarOriginalId: number;
+        sportId: number;
+        status: import("../entities/events/types").EStatusEvent;
+        timeStart: number;
+        tournamentId: number;
+        tournamentTypeRadar: number;
+        providerEvent: import("../entities/events/types").EventProviderId;
+    } | {
+        lines: {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        };
+        linesByMarketId: {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        };
+        awayCorners: number;
+        awayId: number;
+        awayMainScore: number;
+        awayName: string;
+        awayRed: number;
+        awayRedCards: number;
+        awayYellow: number;
+        blockedStatus: number;
+        categoryId: number;
+        counterLines: number;
+        gbId: number;
+        homeCorners: number;
+        homeId: number;
+        homeMainScore: number;
+        homeName: string;
+        homeRedCards: number;
+        homeYellow: number;
+        lineTypeRadar: number;
+        matchStatus: string;
+        matchStatusId: number;
+        matchTime: string;
+        objectId: number;
+        overtime: number;
+        period: number;
+        position: number;
+        providerEvent: import("../entities/events/types").EventProviderId;
+        radarOriginalId: number;
+        remainingTime: string;
+        remainingTimeInPeriod: string;
+        scores: string;
+        sportId: number;
+        status: import("../entities/events/types").EStatusEvent;
+        stopPageTime: string;
+        stopPageTimeAnnounced: string;
+        stopTime: boolean;
+        timeStart: number;
+        tournamentId: number;
+        tournamentTypeRadar: number;
+        tvChanel: string;
+        uid: string;
+        videoId: string;
+        videoProviderId: number;
+        willBeLive: number;
+    } | {
+        lines: {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        };
+        linesByMarketId: {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        };
+        objectId: number;
+        uid: string;
+        awayId: number;
+        awayName: string;
+        blockedStatus: number;
+        willBeLive: number;
+        categoryId: number;
+        gbId: number;
+        homeId: number;
+        homeName: string;
+        lineTypeRadar: number;
+        counterLines: number;
+        radarOriginalId: number;
+        sportId: number;
+        status: import("../entities/events/types").EStatusEvent;
+        timeStart: number;
+        tournamentId: number;
+        tournamentTypeRadar: number;
+        providerEvent: import("../entities/events/types").EventProviderId;
+        awayCorners: number;
+        awayMainScore: number;
+        awayRed: number;
+        awayRedCards: number;
+        awayYellow: number;
+        homeCorners: number;
+        homeMainScore: number;
+        homeRedCards: number;
+        homeYellow: number;
+        matchStatus: string;
+        matchStatusId: number;
+        matchTime: string;
+        overtime: number;
+        period: number;
+        position: number;
+        remainingTime: string;
+        remainingTimeInPeriod: string;
+        scores: string;
+        stopPageTime: string;
+        stopPageTimeAnnounced: string;
+        stopTime: boolean;
+        tvChanel: string;
+        videoId: string;
+        videoProviderId: number;
+    } | {
+        lines: {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        } | {
+            [x: string]: EventLine;
+        };
+        linesByMarketId: {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        } | {
+            [x: number]: EventLine[];
+        };
+        awayCorners: number;
+        awayId: number;
+        awayMainScore: number;
+        awayName: string;
+        awayRed: number;
+        awayRedCards: number;
+        awayYellow: number;
+        blockedStatus: number;
+        categoryId: number;
+        counterLines: number;
+        gbId: number;
+        homeCorners: number;
+        homeId: number;
+        homeMainScore: number;
+        homeName: string;
+        homeRedCards: number;
+        homeYellow: number;
+        lineTypeRadar: number;
+        matchStatus: string;
+        matchStatusId: number;
+        matchTime: string;
+        objectId: number;
+        overtime: number;
+        period: number;
+        position: number;
+        providerEvent: import("../entities/events/types").EventProviderId;
+        radarOriginalId: number;
+        remainingTime: string;
+        remainingTimeInPeriod: string;
+        scores: string;
+        sportId: number;
+        status: import("../entities/events/types").EStatusEvent;
+        stopPageTime: string;
+        stopPageTimeAnnounced: string;
+        stopTime: boolean;
+        timeStart: number;
+        tournamentId: number;
+        tournamentTypeRadar: number;
+        tvChanel: string;
+        uid: string;
+        videoId: string;
+        videoProviderId: number;
+    };
+    getSpecValue(specValues: string[], marketId: number): string;
+    getValidMarketId(marketId: number, event: PrematchEvent | LiveEvent, isPrematch?: boolean): {
+        mainMarket: number;
+        isSpecial: boolean;
+        isShowMoreBtn: boolean;
+        outcomes: number[];
+        isFirstMarket?: undefined;
+    } | {
+        mainMarket: number;
+        isSpecial: boolean;
+        isShowMoreBtn: boolean;
+        outcomes: number[];
+        isFirstMarket: boolean;
+    };
+    getMarketsByComboMarketId(comboMarketId: number, event: PrematchEvent | LiveEvent, isPrematch?: boolean): ReturnGetMarketsByComboMarketIdProps;
+    getOdd(props: GetOddProps): ReturnGetOddType;
+    getMarketById(marketId: number): import("../entities/markets/types").Market;
+    getEventDetailsTabByEvent({ event, isPrematch, sportId, }: {
+        event: PrematchEvent | LiveEvent;
+        isPrematch: boolean;
+        sportId: number;
+    }): number[];
+    getEventDetailsMarketsByGroupId({ event, activeGroupId, isPrematch, sportId, }: {
+        event: PrematchEvent | LiveEvent;
+        activeGroupId: number;
+        sportId: number;
+        isPrematch: boolean;
+    }): (PageMarketInfo & {
+        compareKey: string;
+        availableMarketIds: number[];
+    })[];
+    preparedTournamentsResponse(tournaments: Tournament[], isPrematch: boolean): {
+        id: number;
+        categoryId: number;
+    }[];
+    getAvailableSportIds(isPrematch: boolean): string[];
+    verifyAndUpdateBetsStatus(betsForVerifyStatus: Bet[]): void;
+    verifyAndUpdateExtraBet(): void;
+    getBetSlipLimit(props: GetBetSlipLimitProps): void;
+    getPlaceBetStatus(): EPlaceBetStatus.Unknown | EPlaceBetStatus.ReadyToBet;
+    getExpressOdd(): string;
+    getSystemOdd(rang: number): string;
+    private getCombinations;
+    getBetByBetUid(betUid: string | ECustomBetUid): Bet | ExpressBet | SystemBet | undefined;
+    getComboBoxes(): import("../entities/markets/types").ComboMarketsInfo;
+    getEvents(isPrematch: boolean): import("../entities/events/prematch").PrematchEvents | import("../entities/events/live").LiveEvents;
+    findEventsByTime(events: PrematchEvent[], time: number): PrematchEvent | undefined;
+    createCompoundKey(line: EventLine, event: PrematchEvent | LiveEvent, specValues: string[]): string;
+    getPrefix(line: EventLine, event: PrematchEvent | LiveEvent): string;
+    getEventByEventId(eventUid: string): {
+        isPrematch: boolean;
+        event: PrematchEvent;
+    } | {
+        isPrematch: boolean;
+        event: LiveEvent;
+    };
+    getEventByObjectId(objectId: number, eventUid: string): {
+        isPrematch: boolean;
+        event: PrematchEvent;
+    } | {
+        isPrematch: boolean;
+        event: LiveEvent;
+    };
+    getCashoutSumForOrdinarOrExpress({ stake, type, ordinars }: any): number | false;
+    translateOutcomes(name: string, { home, away }: {
+        home: string;
+        away: string;
+    }): string;
+    replaceOutcomeName(name: string, marketSpecValues: string[], lineSpecifierValues: string[], home?: string, away?: string): string;
+}

package/dist/lib/store/betting/services/types.d.ts

@@ -0,0 +1,42 @@
+import { ComboMarketRowInfo } from 'binary/types';
+import { Bet, EBetType } from '../entities/betslip/types';
+import { EventLine } from '../entities/events/types';
+export type GetOddProps = {
+    isPrematch: boolean;
+    eventUid: string;
+    lineUid: string;
+    outcomeId: number;
+};
+export type ReturnGetOddType = {
+    odd: number | null;
+    status: string;
+    compareKey: string;
+};
+export type SendBetsData = {
+    lineCompoundKey: string;
+    lineTypeRadar: number | string;
+    outcomeId: number;
+};
+export type GetBetSlipLimitProps = {
+    bets: Bet[];
+    betType: EBetType;
+    betUid: string;
+} | {
+    bets: [Bet];
+    betType: EBetType.Ordinar | EBetType.Tinder;
+    betUid: string;
+};
+export type ReturnGetMarketsByComboMarketIdProps = null | AdditionalLines[];
+export type AdditionalLines = {
+    rowMarket: ComboMarketRowInfo;
+    lines: (EventLine & {
+        specValue?: string;
+    })[];
+    name: string;
+    isSpecial: boolean;
+    outcomes: number[];
+};
+export declare enum EOutcomeSpecNames {
+    Home = "{$competitor1}",
+    Away = "{$competitor2}"
+}

package/dist/lib/store/betting/services/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EOutcomeSpecNames = void 0;
+// UTILS
+var EOutcomeSpecNames;
+(function (EOutcomeSpecNames) {
+    EOutcomeSpecNames["Home"] = "{$competitor1}";
+    EOutcomeSpecNames["Away"] = "{$competitor2}";
+})(EOutcomeSpecNames || (exports.EOutcomeSpecNames = EOutcomeSpecNames = {}));

package/dist/lib/store/betting/services/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const marketOutcomeName: (name: string, marketSpecValues: string[], lineSpecifierValues: string[], homeName?: string, awayName?: string) => string;
+export declare const getMarketNameByScheme: (schemeStr: string, names: {
+    homeName: string;
+    awayName: string;
+}, specifierValues: string[]) => string;
+export declare const replaceHtcp: (specValue: string, outcomeNames: string[]) => string;

package/dist/lib/store/betting/services/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceHtcp = exports.getMarketNameByScheme = exports.marketOutcomeName = void 0;
+const marketOutcomeName = (name, marketSpecValues, lineSpecifierValues, homeName = '', awayName = '') => {
+    let str = name;
+    str = str.replaceAll('{$competitor1}', homeName);
+    str = str.replaceAll('{$competitor2}', awayName);
+    str = str.replaceAll('@1', homeName);
+    str = str.replaceAll('@2', awayName);
+    for (let k = 0; k < marketSpecValues.length; k++) {
+        str = str.replace('{%' + marketSpecValues[k] + '}', lineSpecifierValues[k]);
+        str = str.replace('{!' + marketSpecValues[k] + '}', lineSpecifierValues[k]);
+        str = str.replace('{' + marketSpecValues[k] + '}', lineSpecifierValues[k]);
+        str = str.replace('{+' + marketSpecValues[k] + '}', '+' + lineSpecifierValues[k]);
+        str = str.replace('{-' + marketSpecValues[k] + '}', '-' + lineSpecifierValues[k]);
+        str = str.replace('{!(' + marketSpecValues[k] + '+1)}', `${+lineSpecifierValues[k] + 1}`);
+        str = str.replace('{!(' + marketSpecValues[k] + '+2)}', `${+lineSpecifierValues[k] + 2}`);
+        str = str.replace('{!(' + marketSpecValues[k] + '+3)}', `${+lineSpecifierValues[k] + 3}`);
+    }
+    str = str.replace('+-', '-');
+    str = str.replace('--', '+');
+    str = str.split('{').join('');
+    str = str.split('}').join('');
+    str = str.split('(').join('');
+    str = str.split(')').join('');
+    str = str.split('!').join('');
+    str = str.split('%').join('');
+    return str;
+};
+exports.marketOutcomeName = marketOutcomeName;
+const getMarketNameByScheme = (schemeStr, names, specifierValues) => {
+    let str = schemeStr;
+    str = str.replaceAll('@p1', '1');
+    str = str.replaceAll('@p2', '2');
+    str = str.replaceAll('@px', 'X');
+    const text = 'Rospis.Drow';
+    str = str.replaceAll('@x', text);
+    str = str.replaceAll('@2', names.awayName);
+    str = str.replaceAll('@1', names.homeName);
+    if (str === null || str === void 0 ? void 0 : str.includes('@s')) {
+        specifierValues.forEach((specV, inx) => {
+            str = str.replaceAll(`@s${inx}`, specV);
+        });
+    }
+    return str;
+};
+exports.getMarketNameByScheme = getMarketNameByScheme;
+const replaceHtcp = (specValue, outcomeNames) => {
+    let firstPrefix = outcomeNames[0].includes('({+hcp})') ? '+' : '';
+    let secondPrefix = outcomeNames[1].includes('({-hcp})') ? '-' : '';
+    let initStr = specValue;
+    if (initStr === null || initStr === void 0 ? void 0 : initStr.includes('-')) {
+        firstPrefix = '-';
+        secondPrefix = '+';
+        initStr = initStr === null || initStr === void 0 ? void 0 : initStr.replace('-', '');
+    }
+    if ((initStr === null || initStr === void 0 ? void 0 : initStr.includes('+')) && firstPrefix !== '-') {
+        firstPrefix = '+';
+        secondPrefix = '-';
+        initStr = initStr === null || initStr === void 0 ? void 0 : initStr.replace('+', '');
+    }
+    if ((initStr === null || initStr === void 0 ? void 0 : initStr.includes('+')) && firstPrefix === '-') {
+        firstPrefix = '-';
+        secondPrefix = '+';
+        initStr = initStr === null || initStr === void 0 ? void 0 : initStr.replace('+', '');
+    }
+    if (initStr === '0') {
+        return initStr;
+    }
+    const str = `${firstPrefix}${initStr}${secondPrefix}`;
+    return str;
+};
+exports.replaceHtcp = replaceHtcp;

package/dist/lib/store/betting/types.d.ts

@@ -0,0 +1,44 @@
+import { ERequestIds } from 'binary/types';
+import { TCategories } from './entities/categories/types';
+import { LiveEvent } from './entities/events/live/types';
+import { PrematchEvent } from './entities/events/prematch/types';
+import { ComboMarketsInfo, TMarkets } from './entities/markets/types';
+import { TSports } from './entities/sports/types';
+import { TTournaments } from './entities/tournaments/types';
+import { BackOfficeSettings } from 'service/responseAdapter/types';
+export type EntitiesProps = {
+    tournaments: TTournaments;
+    sports: TSports;
+    categories: TCategories;
+    markets: TMarkets;
+    marketList: ComboMarketsInfo;
+    backOfficeSettings: BackOfficeSettings;
+};
+export type BettingSettings = {
+    isBetRadarLiveDisabled: boolean;
+    isBetRadarPrematchDisabled: boolean;
+    isBazarLiveDisabled: boolean;
+    isBazarPrematchDisabled: boolean;
+    minStake: number;
+    cashOut: number;
+    coeffPayout: number;
+    countEventsTop: number;
+    countTopPrematch: number;
+    countTopLive: number;
+    countEventsLive: number;
+    countEventsUpcoming: number;
+    frequencyMinTop: number;
+};
+export type HandleEventUpdatesProps = {
+    events: EventsProps;
+    requestId: ERequestIds.Unknown | ERequestIds.ExtraLines;
+};
+export type EventsProps = {
+    [key: string]: PrematchEvent | LiveEvent;
+};
+export type SubscribeBettingStatusProps = {
+    uid: string;
+    callback: (status: {
+        status: boolean;
+    }) => void;
+};

package/dist/lib/store/betting/types.js

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

package/dist/lib/store/casino/entities/casinoTournaments/index.d.ts

@@ -0,0 +1,43 @@
+import { TournamentPlayer, CurrentTournamentPlayer, AdaptedCasinoTournament, InitialTournaments, RequestCommands, TournamentSettings, CasinoTournamentsProps, ProviderTournament, InHouseTournaments, TournamentSubscribeProps } from './types';
+import { TournamentServices } from './service';
+import { ObservableEntity } from 'service/observableEntity';
+import { UpdateData } from 'service/observable/type';
+import { SendCommand } from 'socket/types';
+import { ResponseAdapter } from 'service/responseAdapter';
+export declare class CasinoTournaments extends ObservableEntity<undefined> {
+    services: TournamentServices;
+    _isRequested: RequestCommands;
+    parent: ResponseAdapter;
+    sendCommand: SendCommand;
+    tournamentSettings: TournamentSettings;
+    _inHouseTournaments: InHouseTournaments;
+    _providerTournaments: {
+        finished: ProviderTournament[];
+        active: ProviderTournament[];
+    };
+    tournamentPlayers: {
+        [id: number]: TournamentPlayer[];
+    };
+    tournaments: {
+        [id: number]: AdaptedCasinoTournament;
+    };
+    currentUserInfo: {
+        [tournamentId: number]: CurrentTournamentPlayer;
+    };
+    constructor({ parent, sendCommand, tournamentSettings, }: CasinoTournamentsProps);
+    set inHouseTournaments(tournaments: InHouseTournaments);
+    get inHouseTournaments(): InHouseTournaments;
+    set providerTournaments(v: {
+        finished: ProviderTournament[];
+        active: ProviderTournament[];
+    });
+    get providerTournaments(): {
+        finished: ProviderTournament[];
+        active: ProviderTournament[];
+    };
+    set isRequested(v: RequestCommands);
+    get isRequested(): RequestCommands;
+    setInHouseTournaments(tournaments: InitialTournaments): void;
+    updateActiveInHouseBattle(result: InitialTournaments): void;
+    sendUpdateEntity(props: TournamentSubscribeProps): UpdateData | null;
+}

package/dist/lib/store/casino/entities/casinoTournaments/service/constants.d.ts

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

package/dist/lib/store/casino/entities/casinoTournaments/service/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROVIDER_PLAYERS = void 0;
+const DEFAULT = { id: 1, payout: '', payoutBonus: '', rolled: '' };
+exports.DEFAULT_PROVIDER_PLAYERS = [
+    DEFAULT,
+    DEFAULT,
+    DEFAULT,
+    DEFAULT,
+    DEFAULT,
+].map((d, inx) => (Object.assign(Object.assign({}, d), { id: inx })));

package/dist/lib/store/casino/entities/casinoTournaments/service/index.d.ts

@@ -0,0 +1,18 @@
+import { UpdateData } from 'service/observable/type';
+import { CasinoTournaments } from 'store/casino/entities/casinoTournaments';
+import { BattleHookInfo, BattleInfo, ProviderTournament, TournamentInfo } from 'store/casino/entities/casinoTournaments/types';
+export declare class TournamentServices {
+    parent: CasinoTournaments;
+    constructor(parent: CasinoTournaments);
+    getTournamentById(info: BattleInfo, isMobile: boolean): UpdateData | null;
+    private getImages;
+    requestTournaments(isSocket?: boolean): Promise<void>;
+    getHistoryTournaments(): {
+        data: BattleHookInfo[];
+        isArray: boolean;
+        property: string;
+        withCompare: boolean;
+    };
+    getActiveTournaments(): null | UpdateData;
+    convertTournamentToBaseType(isProviderBattle: boolean, battle: TournamentInfo | ProviderTournament, isHistory?: boolean, convertPlayers?: boolean): BattleHookInfo;
+}