react-memory-optimization 0.0.1

package/dist/lib/store/betting/entities/sports/index.d.ts

@@ -0,0 +1,20 @@
+import { BettingServices } from '../../services';
+import { Observable } from '../../../../service/observable';
+import { ObservableSettings, SubscribeSportInfoBySportIdProps, SubscribeSportsProps, TSports } from './types';
+export declare class Sports {
+    sportsObservable: Observable;
+    observableSettings: ObservableSettings;
+    sports: TSports;
+    isFirstData: boolean;
+    services: BettingServices;
+    constructor(bettingServices: BettingServices);
+    updateSports(sports: TSports): void;
+    setSports(sports: TSports): void;
+    private sendSports;
+    private sendSport;
+    updateSubscribers(): void;
+    subscribeSports({ uid, callback, isPrematch }: SubscribeSportsProps): void;
+    subscribeSportInfoBySportId({ uid, callback, sportId, }: SubscribeSportInfoBySportIdProps): void;
+    unsubscribeSportEntities(uid: string): void;
+    reset(): void;
+}

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

@@ -0,0 +1,62 @@
+export type TSports = {
+    [id: number]: Sport;
+};
+export type Sport = {
+    id: number;
+    name: string;
+    sortId: number;
+};
+export declare enum ESports {
+    Basketball = 1016,
+    BeachVolleyball = 1017,
+    Cricket = 1021,
+    Soccer = 1023,
+    IceHockey = 1027,
+    HandBall = 1028,
+    Tennis = 1034,
+    TableTennis = 1033,
+    Volleyball = 1035,
+    Basketbal3X3 = 1181,
+    CyberSports = 1202,
+    Fifa = 1449,
+    ENHL = 1450,
+    ENBA = 1451,
+    Futsal = 1103,
+    Snooker = 1036,
+    Badminton = 1014,
+    Squash = 1107,
+    Kabaddi = 1174,
+    Baseball = 1015,
+    AmericanFootball = 1012,
+    AussieRules = 1013,
+    Rugby = 1031,
+    BeachSoccer = 1112,
+    Boxing = 1020,
+    Darts = 1022,
+    Waterpolo = 1042,
+    Chess = 1109,
+    FieldHockey = 1126,
+    Pesapallo = 1127,
+    MMA = 1179
+}
+export type ObservableSettings = {
+    [uid: string]: ObservableSportsSetting | ObservableSportSetting;
+};
+export type ObservableSportsSetting = {
+    isSports: boolean;
+    isPrematch: boolean;
+};
+export type ObservableSportSetting = {
+    isSport: boolean;
+    sportId: number;
+};
+export type SubscribeSportsProps = {
+    uid: string;
+    isPrematch: boolean;
+    callback: (info: Sport[]) => void;
+};
+export type SubscribeSportInfoBySportIdProps = {
+    uid: string;
+    callback: (info: Sport | null) => void;
+    sportId: number;
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESports = void 0;
+var ESports;
+(function (ESports) {
+    ESports[ESports["Basketball"] = 1016] = "Basketball";
+    ESports[ESports["BeachVolleyball"] = 1017] = "BeachVolleyball";
+    ESports[ESports["Cricket"] = 1021] = "Cricket";
+    ESports[ESports["Soccer"] = 1023] = "Soccer";
+    ESports[ESports["IceHockey"] = 1027] = "IceHockey";
+    ESports[ESports["HandBall"] = 1028] = "HandBall";
+    ESports[ESports["Tennis"] = 1034] = "Tennis";
+    ESports[ESports["TableTennis"] = 1033] = "TableTennis";
+    ESports[ESports["Volleyball"] = 1035] = "Volleyball";
+    ESports[ESports["Basketbal3X3"] = 1181] = "Basketbal3X3";
+    ESports[ESports["CyberSports"] = 1202] = "CyberSports";
+    ESports[ESports["Fifa"] = 1449] = "Fifa";
+    ESports[ESports["ENHL"] = 1450] = "ENHL";
+    ESports[ESports["ENBA"] = 1451] = "ENBA";
+    ESports[ESports["Futsal"] = 1103] = "Futsal";
+    ESports[ESports["Snooker"] = 1036] = "Snooker";
+    ESports[ESports["Badminton"] = 1014] = "Badminton";
+    ESports[ESports["Squash"] = 1107] = "Squash";
+    ESports[ESports["Kabaddi"] = 1174] = "Kabaddi";
+    ESports[ESports["Baseball"] = 1015] = "Baseball";
+    ESports[ESports["AmericanFootball"] = 1012] = "AmericanFootball";
+    ESports[ESports["AussieRules"] = 1013] = "AussieRules";
+    ESports[ESports["Rugby"] = 1031] = "Rugby";
+    ESports[ESports["BeachSoccer"] = 1112] = "BeachSoccer";
+    ESports[ESports["Boxing"] = 1020] = "Boxing";
+    ESports[ESports["Darts"] = 1022] = "Darts";
+    ESports[ESports["Waterpolo"] = 1042] = "Waterpolo";
+    ESports[ESports["Chess"] = 1109] = "Chess";
+    ESports[ESports["FieldHockey"] = 1126] = "FieldHockey";
+    ESports[ESports["Pesapallo"] = 1127] = "Pesapallo";
+    ESports[ESports["MMA"] = 1179] = "MMA";
+})(ESports || (exports.ESports = ESports = {}));

package/dist/lib/store/betting/entities/tickets/index.d.ts

@@ -0,0 +1,26 @@
+import { BettingServices } from 'store/betting/services';
+import { ObservableSettings, SetInitialInGameTickets, SubscribeHistoryTicketsInfoProps, SubscribeTicketInfoProps, SubscribeTicketsProps, Ticket, Tickets } from './types';
+import { Observable } from 'service/observable';
+import { HandleTicketResultProps } from 'service/responseAdapter/types';
+export declare class BettingTickets {
+    services: BettingServices;
+    observableTickets: Observable;
+    observableSettings: ObservableSettings;
+    tickets: Tickets;
+    constructor(services: BettingServices);
+    setInitialInGameTickets(inGameTickets: SetInitialInGameTickets): void;
+    updateTicket(ticket: HandleTicketResultProps): void;
+    updateTickets(newTickets: Ticket[]): void;
+    private sendCashoutUpdates;
+    private sendInGameLiveTickets;
+    private sendAllTickets;
+    private sendTicketInfo;
+    private sendHistoryTicketInfo;
+    sendUpdates(): void;
+    subscribeCashOutTickets({ uid, callback }: SubscribeTicketsProps): void;
+    subscribeInGameLiveTickets({ uid, callback }: SubscribeTicketsProps): void;
+    subscribeInGameTickets({ uid, callback }: SubscribeTicketsProps): void;
+    subscribeTicketInfo({ uid, callback, ticketId }: SubscribeTicketInfoProps): void;
+    subscribeHistoryTickets({ uid, callback, range, }: SubscribeHistoryTicketsInfoProps): void;
+    unsubscribeTicketsEntity(uid: string): void;
+}

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

@@ -0,0 +1,105 @@
+export type SetInitialInGameTickets = {
+    [inx: number]: {
+        ticket: Ticket;
+    };
+};
+export type Ticket = {
+    acceptedOdd: number;
+    balanceType: number;
+    bonusBalance: number;
+    cashoutRecords: any[];
+    id: number;
+    isTinderBet: boolean;
+    ordinars: Ordinar[];
+    ordinarsNumber: number;
+    parentId: number;
+    payout: number;
+    points: number;
+    returned: number;
+    settlementOdd: number;
+    stake: number;
+    status: ETicketStatus;
+    systemRang: number;
+    timestamp: number;
+    timestampPayout: number;
+    timestampSettlement: number;
+    type: ETicketType;
+};
+export declare enum ETicketStatus {
+    Unsettled = 0,
+    Settled = 1
+}
+export declare enum ETicketType {
+    Ordinar = 1,
+    Express = 2,
+    System = 3,
+    BetBuilder = 4,
+    Tinder = 5
+}
+export type Tickets = {
+    [ticketId: number]: Ticket;
+};
+export type Ordinar = {
+    acceptedOdd: number;
+    categoryName: string;
+    eventAwayName: string;
+    eventGameScore: string;
+    eventHomeName: string;
+    eventId: string;
+    eventMatchStatusDescription: string;
+    eventMatchTime: string;
+    eventScore: string;
+    eventSetScore: string;
+    eventStartTime: number;
+    eventStatus: number;
+    gbEventId: number;
+    id: number;
+    lineCompoundKey: string;
+    lineTypeRadar: number;
+    lmtId: number;
+    marketId: number;
+    marketName: string;
+    outcomeId: number;
+    outcomeName: string;
+    settlementOdd: number;
+    specifierValue: any[];
+    sportName: string;
+    status: number;
+    summary: string;
+    tournamentName: string;
+    variant: number;
+};
+export type ObservableSettings = {
+    [uid: string]: ObservableSettingCashOut | ObservableSettingInGameLive | ObservableSettingHistoryTicketInfo | ObservableSettingInGame | ObservableSettingTicketInfo;
+};
+export type ObservableSettingCashOut = {
+    inGameCashOut: true;
+};
+export type ObservableSettingInGameLive = {
+    inGameLive: true;
+};
+export type ObservableSettingInGame = {
+    inGameAll: true;
+};
+export type ObservableSettingTicketInfo = {
+    isTicket: true;
+    ticketId: number;
+};
+export type ObservableSettingHistoryTicketInfo = {
+    isTicketHistory: true;
+    range: [number, number];
+};
+export type SubscribeTicketsProps = {
+    uid: string;
+    callback: (d: any[]) => void;
+};
+export type SubscribeTicketInfoProps = {
+    uid: string;
+    ticketId: number;
+    callback: (d: Ticket) => void;
+};
+export type SubscribeHistoryTicketsInfoProps = {
+    uid: string;
+    range: [number, number];
+    callback: (d: Ticket[]) => void;
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ETicketType = exports.ETicketStatus = void 0;
+var ETicketStatus;
+(function (ETicketStatus) {
+    ETicketStatus[ETicketStatus["Unsettled"] = 0] = "Unsettled";
+    ETicketStatus[ETicketStatus["Settled"] = 1] = "Settled";
+})(ETicketStatus || (exports.ETicketStatus = ETicketStatus = {}));
+var ETicketType;
+(function (ETicketType) {
+    ETicketType[ETicketType["Ordinar"] = 1] = "Ordinar";
+    ETicketType[ETicketType["Express"] = 2] = "Express";
+    ETicketType[ETicketType["System"] = 3] = "System";
+    ETicketType[ETicketType["BetBuilder"] = 4] = "BetBuilder";
+    ETicketType[ETicketType["Tinder"] = 5] = "Tinder";
+})(ETicketType || (exports.ETicketType = ETicketType = {}));

package/dist/lib/store/betting/entities/tournaments/index.d.ts

@@ -0,0 +1,30 @@
+import { BettingServices } from '../../services';
+import { Observable } from '../../../../service/observable';
+import { CategoryTournament, ObservableSettingsType, SubscribeBettingTopTournamentsProps, SubscribeBettingTournamentsByCategoryIdOrSportIdProps, SubscribeBettingTournamentsByIdProps, TTournaments, Tournament } from './types';
+export declare class Tournaments {
+    services: BettingServices;
+    topTournamentsObservable: Observable;
+    tournamentsObservable: Observable;
+    tournaments: TTournaments;
+    tournamentByCategoryId: CategoryTournament;
+    isInitTournaments: boolean;
+    topTournaments: {
+        [tournamentId: number]: Tournament;
+    };
+    settingTournamentObservable: ObservableSettingsType;
+    constructor(services: BettingServices);
+    updateTournaments(tournaments: TTournaments): void;
+    updateTopTournaments(): void;
+    setTournaments(tournaments: TTournaments): void;
+    private sendTournamentIdUpdate;
+    private sendTournamentsBySportId;
+    private sendTournamentsByCategoryIdUpdates;
+    sendTournamentUpdates(): void;
+    subscribeTopTournaments({ uid, callback, }: SubscribeBettingTopTournamentsProps): void;
+    unsubscribeTopTournaments(uid: string): void;
+    subscribeBettingTournamentsByCategoryIdOrSportId(props: SubscribeBettingTournamentsByCategoryIdOrSportIdProps): void;
+    unsubscribeBettingTournamentsByCategoryIdOrSportId(uid: string): void;
+    subscribeTournamentsById(props: SubscribeBettingTournamentsByIdProps): void;
+    unsubscribeTournamentsById(uid: string): void;
+    reset(): void;
+}

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

@@ -0,0 +1,69 @@
+export type TTournaments = {
+    [id: number]: Tournament;
+};
+export type Tournament = {
+    categoryId: number;
+    id: number;
+    name: string;
+    seasonId: number;
+    sortId: number;
+    sportId: number;
+    typeRadar: number;
+};
+export type CategoryTournament = {
+    [categoryId: number]: {
+        [tournamentId: number]: number;
+    };
+};
+export type ObservableSettingsType = {
+    [uid: string]: ObservableSettingType;
+};
+export type ObservableSettingType = {
+    isPrematch: boolean;
+    categoryId: number;
+    time: number | null;
+} | {
+    tournamentId: number;
+} | {
+    sportId: number;
+    isPrematch: boolean;
+    time: number | null;
+};
+export type SubscribeBettingTopTournamentsProps = {
+    uid: string;
+    callback: (status: Tournament[]) => void;
+};
+export type SubscribeBettingTournamentsByCategoryIdOrSportIdProps = {
+    uid: string;
+    categoryId?: number;
+    sportId?: number;
+    isPrematch: boolean;
+    time: number | null;
+    callback: (info: {
+        id: number;
+        categoryId: number;
+    }[]) => void;
+} & ({
+    sportId: number;
+    categoryId?: undefined;
+} | {
+    sportId?: undefined;
+    categoryId: number;
+});
+export type SubscribeBettingTournamentsByIdProps = {
+    uid: string;
+    tournamentId: number;
+    callback: (info: Tournament | null) => void;
+};
+export type SendTournamentsBySportIdProps = {
+    sportId: number;
+    uid: string;
+    isPrematch: boolean;
+    time: null | number;
+};
+export type SendTournamentsByCategoryIdUpdatesProps = {
+    categoryId: number;
+    uid: string;
+    isPrematch: boolean;
+    time: null | number;
+};

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

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

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

@@ -0,0 +1,45 @@
+import { Categories } from './entities/categories';
+import { Events } from './entities/events';
+import { BettingMarkets } from './entities/markets';
+import { Sports } from './entities/sports';
+import { Tournaments } from './entities/tournaments';
+import { Observable } from '../../service/observable';
+import { EntitiesProps, HandleEventUpdatesProps, SubscribeBettingStatusProps } from './types';
+import { BettingServices } from './services';
+import { SendCommand, TBettingSettings } from '../../socket/types';
+import { BetSlip } from './entities/betslip';
+import { BettingTickets } from './entities/tickets';
+import { ResponseAdapterService } from 'service/responseAdapter/services';
+import { BackOfficeSettings } from 'service/responseAdapter/types';
+export declare class Betting {
+    markets: BettingMarkets;
+    categories: Categories;
+    tournaments: Tournaments;
+    bettingSettings: TBettingSettings;
+    sports: Sports;
+    events: Events;
+    betSlip: BetSlip;
+    tickets: BettingTickets;
+    _banUserCashOut: boolean;
+    bettingServices: BettingServices;
+    bettingObservable: Observable;
+    bettingSettingsObservable: Observable;
+    sendCommand: SendCommand;
+    callbackCommand: SendCommand;
+    private _isBettingAvailable;
+    _isSettingInstalled: boolean;
+    constructor(bettingSettings: TBettingSettings, sendCommand: SendCommand, adapterService: ResponseAdapterService);
+    set banUserCashOut(state: boolean);
+    get banUserCashOut(): boolean;
+    set isBettingAvailable(value: boolean);
+    get isBettingAvailable(): boolean;
+    getConfigurations(): Promise<void>;
+    updateBackOfficeSettings(result: BackOfficeSettings): void;
+    updateEntities(result: EntitiesProps): void;
+    handleEventUpdates(result: HandleEventUpdatesProps): void;
+    subscribeBettingStatus({ uid, callback }: SubscribeBettingStatusProps): void;
+    unsubscribeBettingStatus(uid: string): void;
+    subscribeBettingSettingsStatus({ uid, callback, }: SubscribeBettingStatusProps): void;
+    unsubscribeBettingSettingsStatus(uid: string): void;
+    resetBettingStates(): void;
+}

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKETS_WITHOUT_CASHOUT = void 0;
+exports.MARKETS_WITHOUT_CASHOUT = [
+    30103, 30104, 30123, 30149, 30192, 30229, 30251, 30252, 30261, 30263, 30286,
+    30291, 30326, 30336, 30345, 30370, 30380, 30401, 30409, 30430, 30433, 30452,
+    30457, 30485, 30498, 30499, 30506, 30507, 30515, 30575, 30576, 30579, 30599,
+    30620, 30669, 30684, 30685, 30721, 30722, 30726, 30732, 30736, 30741, 30802,
+    30806, 30807, 30817, 30824, 30831, 30867, 30878, 30894, 30895, 30908, 30910,
+    30949, 30998, 31023, 31027, 31642, 31661,
+];