react-memory-optimization 0.0.1

package/dist/lib/store/operations/entities/activeBonuses/index.d.ts

@@ -0,0 +1,18 @@
+import { AvailableBonusesType, UpdateActiveBonusesProps } from './types';
+import { UserOperationServices } from 'store/operations/services';
+import { CancelOperationProps, Operation } from 'store/operations/types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class ActiveBonuses extends ObservableEntity<unknown> {
+    services: UserOperationServices;
+    bonuses: AvailableBonusesType;
+    constructor(services: UserOperationServices);
+    updateActiveBonuses({ activeBonusOnDeposit, activeFreeSpins, }: UpdateActiveBonusesProps): void;
+    updateOperations(operations: Operation[]): void;
+    private sendAvailableBonuses;
+    cancelOperation(props: CancelOperationProps): void;
+    sendUpdateEntity(d: BaseObservableSubscriber & {
+        [key: string]: unknown;
+    }): UpdateData | null;
+    reset(): void;
+}

package/dist/lib/store/operations/entities/activeBonuses/types.d.ts

@@ -0,0 +1,8 @@
+import { CasinoBonusFreeSpinOperation, CasinoBonusOnDepositOperation } from 'store/operations/types';
+export type UpdateActiveBonusesProps = {
+    activeBonusOnDeposit: CasinoBonusOnDepositOperation[];
+    activeFreeSpins: CasinoBonusFreeSpinOperation[];
+};
+export type AvailableBonusesType = {
+    [id: number]: CasinoBonusFreeSpinOperation | CasinoBonusOnDepositOperation;
+};

package/dist/lib/store/operations/entities/activeBonuses/types.js

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

package/dist/lib/store/operations/entities/availableBonuses/index.d.ts

@@ -0,0 +1,18 @@
+import { AvailableBonusesType, UpdateAvailableBonusesProps } from './types';
+import { UserOperationServices } from 'store/operations/services';
+import { CancelOperationProps, Operation } from 'store/operations/types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class AvailableBonuses extends ObservableEntity<unknown> {
+    services: UserOperationServices;
+    bonuses: AvailableBonusesType;
+    constructor(services: UserOperationServices);
+    updateAvailableBonuses(props: UpdateAvailableBonusesProps): void;
+    updateOperations(operations: Operation[]): void;
+    private sendAvailableBonuses;
+    cancelOperation(props: CancelOperationProps): void;
+    sendUpdateEntity(d: BaseObservableSubscriber & {
+        [key: string]: unknown;
+    }): UpdateData | null;
+    reset(): void;
+}

package/dist/lib/store/operations/entities/availableBonuses/types.d.ts

@@ -0,0 +1,8 @@
+import { CasinoBonusFreeSpinOperation, CasinoBonusOnDepositOperation } from 'store/operations/types';
+export type UpdateAvailableBonusesProps = {
+    availableBonusOnDeposit: CasinoBonusOnDepositOperation[];
+    availableFreeSpins: CasinoBonusFreeSpinOperation[];
+};
+export type AvailableBonusesType = {
+    [id: number]: CasinoBonusFreeSpinOperation | CasinoBonusOnDepositOperation;
+};

package/dist/lib/store/operations/entities/availableBonuses/types.js

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

package/dist/lib/store/operations/entities/cashBonuses/index.d.ts

@@ -0,0 +1,49 @@
+import { ChannelType } from '../../types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+import { CashBonusChannelType, CashOperation } from './types';
+export declare class CashBonuses extends ObservableEntity<undefined> {
+    cashBonuses: CashOperation[];
+    constructor();
+    isCashBonusType(type: ChannelType): boolean;
+    update(channelType?: CashBonusChannelType): {
+        data: {
+            compareKey: string;
+            amount: number;
+            channelType: ChannelType;
+            completionTimestamp: number;
+            creationTimestamp: number;
+            currency: number;
+            deposit: number;
+            direction: import("../../types").EOperationDirect;
+            endTimestamp: number;
+            fee: number;
+            fullRolled: number;
+            id: number;
+            isCancelableByUser: boolean;
+            isCanceledByUser: boolean;
+            maxBet: number;
+            notice: number;
+            postponedStatus: number;
+            provider: number;
+            providerId: string | number;
+            providerStatus: number;
+            rolled: number;
+            startTimestamp: number;
+            status: import("../../types").EOperationStatus;
+            tax: number;
+            type: import("../../types").EOperationType;
+            url: string;
+            wager: number;
+        }[];
+        isArray: boolean;
+        withCompare: boolean;
+        property: string;
+    };
+    setCashBonuses(cashBonuses: CashOperation[]): void;
+    updateOperations(d: any): void;
+    sendUpdateEntity({ channelType, }: BaseObservableSubscriber & {
+        channelType: CashBonusChannelType;
+    }): UpdateData | null;
+    reset(): void;
+}

package/dist/lib/store/operations/entities/cashBonuses/types.d.ts

@@ -0,0 +1,3 @@
+import { ChannelType, CommonOperationProperties } from 'store/operations/types';
+export type CashBonusChannelType = ChannelType.CashPromoAccural | ChannelType.BonusPromoAccural | ChannelType.Egt;
+export type CashOperation = CommonOperationProperties;

package/dist/lib/store/operations/entities/cashBonuses/types.js

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

package/dist/lib/store/operations/entities/casinoHistory/index.d.ts

@@ -0,0 +1,18 @@
+import { ObservableEntity } from 'service/observableEntity';
+import { CasinoHistoryBet, CasinoHistoryGamesSubscriber } from './types';
+import { UpdateData } from 'service/observable/type';
+export declare class CasinoGames extends ObservableEntity<undefined> {
+    gameHistory: CasinoHistoryBet[];
+    constructor();
+    setCasinoGameHistory(gameHistory: CasinoHistoryBet[]): void;
+    updateOperations(info: any): void;
+    addCasinoGameOperations(games: CasinoHistoryBet[]): void;
+    sendGameHistory(range: [number, number]): UpdateData | null;
+    sendUpdateEntity(d: CasinoHistoryGamesSubscriber): {
+        data: string[];
+        isArray: boolean;
+        withCompare: boolean;
+        property: string;
+    };
+    reset(): void;
+}

package/dist/lib/store/operations/entities/casinoHistory/types.d.ts

@@ -0,0 +1,15 @@
+import { BaseObservableSubscriber } from 'service/observable/type';
+export type CasinoHistoryBet = {
+    betsAmount: number;
+    betsNumber: number;
+    convertToObj: unknown;
+    creationTimestamp: number;
+    dateEnd: number;
+    gameId: number;
+    id: number;
+    refundsAmount: number;
+    refundsNumber: number;
+    winsAmount: number;
+    winsNumber: number;
+};
+export type CasinoHistoryGamesSubscriber = BaseObservableSubscriber;

package/dist/lib/store/operations/entities/casinoHistory/types.js

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

package/dist/lib/store/operations/entities/payments/index.d.ts

@@ -0,0 +1,31 @@
+import { CancelOperationProps, PaymentOperation, EOperationStatus, TransactionFilterType } from '../../types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class Payments extends ObservableEntity<undefined> {
+    payments: PaymentOperation[];
+    constructor();
+    isExistPaymentTypes(types: TransactionFilterType[]): boolean;
+    update(): {
+        data: {
+            compareKey: string;
+            amount: number;
+            completionTimestamp: number;
+            creationTimestamp: number;
+            direction: import("../../types").EOperationDirect;
+            id: number;
+            status: EOperationStatus;
+            type: import("../../types").EOperationType;
+            canBeCanceled?: boolean;
+        }[];
+        isArray: boolean;
+        withCompare: boolean;
+        property: string;
+    };
+    cancelOperation(operation: CancelOperationProps): void;
+    setPayments(payments: PaymentOperation[]): void;
+    updateOperations(d: any): void;
+    sendUpdateEntity(d: BaseObservableSubscriber & {
+        [key: string]: unknown;
+    }): UpdateData | null;
+    reset(): void;
+}

package/dist/lib/store/operations/entities/referralOperations/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+import { ObservableEntity } from 'service/observableEntity';
+import { CommonOperationProperties } from 'store/operations/types';
+export declare class ReferralOperation extends ObservableEntity<undefined> {
+    _operations: any[];
+    constructor();
+    set operations(operations: any[]);
+    get operations(): any[];
+    updateOperations(operations: CommonOperationProperties[]): void;
+    sendUpdateEntity(info: BaseObservableSubscriber): UpdateData;
+}

package/dist/lib/store/operations/entities/tournaments/constants.d.ts

@@ -0,0 +1,2 @@
+import { ChannelType } from 'store/operations/types';
+export declare const TOURNAMENTS: ChannelType[];

package/dist/lib/store/operations/entities/tournaments/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOURNAMENTS = void 0;
+const types_1 = require("store/operations/types");
+exports.TOURNAMENTS = [
+    types_1.ChannelType.TournamentPayoutCash,
+    types_1.ChannelType.TournamentPayoutBonus,
+];

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

@@ -0,0 +1,24 @@
+import { CancelOperationProps, CommonOperationProperties } from 'store/operations/types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class TournamentOperations extends ObservableEntity<undefined> {
+    activeTournaments: CommonOperationProperties[];
+    finishedTournaments: CommonOperationProperties[];
+    constructor();
+    reset(): void;
+    updateOperations(tournaments: CommonOperationProperties[]): void;
+    cancelOperation(operation: CancelOperationProps): void;
+    setTournaments(tournaments: {
+        o: CommonOperationProperties;
+        isActive: boolean;
+    }[]): void;
+    sendTournaments(data: CommonOperationProperties[]): {
+        data: CommonOperationProperties[];
+        isArray: boolean;
+        withCompare: boolean;
+        property: string;
+    };
+    sendUpdateEntity({ isActive, }: BaseObservableSubscriber & {
+        isActive: boolean;
+    }): UpdateData | null;
+}

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

@@ -0,0 +1,9 @@
+import { CommonOperationProperties } from 'store/operations/types';
+export type ObservableTournamentSettings = {
+    isActive: boolean;
+};
+export type SubscribeTournaments = {
+    isActive: boolean;
+    uid: string;
+    callback: (i: CommonOperationProperties[]) => void;
+};

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

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

package/dist/lib/store/operations/entities/vipClub/cosntants.d.ts

@@ -0,0 +1,3 @@
+import { ChannelType, TransactionFilterType } from '../../types';
+export declare const VIP_CLUB_CHANNEL_TYPES: ChannelType[];
+export declare const VIP_CLUB_FILTER_TYPES: TransactionFilterType[];

package/dist/lib/store/operations/entities/vipClub/cosntants.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIP_CLUB_FILTER_TYPES = exports.VIP_CLUB_CHANNEL_TYPES = void 0;
+const types_1 = require("../../types");
+exports.VIP_CLUB_CHANNEL_TYPES = [
+    types_1.ChannelType.NewLoyaltyLevel,
+    types_1.ChannelType.VipClubLevel,
+    types_1.ChannelType.RakeBack,
+    types_1.ChannelType.Monthly,
+    types_1.ChannelType.Weekly,
+];
+exports.VIP_CLUB_FILTER_TYPES = [
+    types_1.TransactionFilterType.ActiveRakeBack,
+    types_1.TransactionFilterType.ActiveMonthly,
+    types_1.TransactionFilterType.ActiveWeekly,
+    types_1.TransactionFilterType.RakeBackHistory,
+    types_1.TransactionFilterType.MonthlyHistory,
+    types_1.TransactionFilterType.WeeklyHistory,
+    types_1.TransactionFilterType.NewVipLevelHistory,
+    types_1.TransactionFilterType.EgtHistory,
+];

package/dist/lib/store/operations/entities/vipClub/index.d.ts

@@ -0,0 +1,64 @@
+import { CancelOperationProps, ChannelType, EOperationStatus, Operation, VipClubLevelOperation } from '../../types';
+import { RakeBackOperation, UpdateVipClubEntityKey } from './types';
+import { ObservableEntity } from 'service/observableEntity';
+import { BaseObservableSubscriber, UpdateData } from 'service/observable/type';
+export declare class VipClub extends ObservableEntity<undefined> {
+    rakeback: null | RakeBackOperation;
+    weekly: null | Operation;
+    monthly: null | Operation;
+    rakeBackHistory: Operation[];
+    vipClubLevelHistory: VipClubLevelOperation[];
+    vipClubWeeklyHistory: Operation[];
+    vipClubMonthlyHistory: Operation[];
+    constructor();
+    private validateBoost;
+    updateSubscribes(updateConfig: BaseObservableSubscriber & UpdateVipClubEntityKey): {
+        data: ({
+            compareKey: string;
+            amount: number;
+            channelType: ChannelType;
+            completionTimestamp: number;
+            creationTimestamp: number;
+            currency: number;
+            deposit: number;
+            direction: import("../../types").EOperationDirect;
+            endTimestamp: number;
+            fee: number;
+            fullRolled: number;
+            id: number;
+            isCancelableByUser: boolean;
+            isCanceledByUser: boolean;
+            maxBet: number;
+            notice: number;
+            postponedStatus: number;
+            provider: number;
+            providerId: string | number;
+            providerStatus: number;
+            rolled: number;
+            startTimestamp: number;
+            status: EOperationStatus;
+            tax: number;
+            type: import("../../types").EOperationType;
+            url: string;
+            wager: number;
+        } | {
+            amount: number;
+            endData: number;
+            id: number;
+            compareKey: string;
+        } | {
+            compareKey: string;
+            id: number;
+            rakeback: number;
+            isBoost: boolean;
+            endTime: number;
+        })[];
+        withCompare: boolean;
+        property: string;
+        isArray: boolean;
+    };
+    update(operations: Operation[]): void;
+    setOperations(operations: Operation[]): void;
+    cancelOperation({ operationId }: CancelOperationProps): void;
+    sendUpdateEntity(d: BaseObservableSubscriber & UpdateVipClubEntityKey): UpdateData | null;
+}

package/dist/lib/store/operations/entities/vipClub/types.d.ts

@@ -0,0 +1,31 @@
+import { ChannelType, Operation } from '../../../operations/types';
+export type UpdateVipClubEntityKey = {
+    isRakeback: boolean;
+    isWeekly: boolean;
+    isMonthly: boolean;
+    isRakeBackHistory: boolean;
+    isVipClubEgtHistory: boolean;
+    isVipClubLevelHistory: boolean;
+    isVipClubWeeklyHistory: boolean;
+    isVipClubMonthlyHistory: boolean;
+};
+export type RakeBackOperation = Operation & {
+    rakeBackBoost: number;
+    channelType: ChannelType.RakeBack;
+};
+export type ReturnTypeRakeBake = {
+    id: number;
+    rakeback: number;
+    isBoost: boolean;
+    endTime: number;
+};
+export type ReturnTypeWeeklyBonus = {
+    amount: number;
+    endData: number;
+    id: number;
+};
+export type ReturnTypeMonthlyBonus = {
+    amount: number;
+    endData: number;
+    id: number;
+};

package/dist/lib/store/operations/entities/vipClub/types.js

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

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

@@ -0,0 +1,49 @@
+import { SubscribeComposeTransactionsProps } from '../../socket/methodTypes';
+import { Payments } from './entities/payments';
+import { CasinoGames } from './entities/casinoHistory';
+import { CancelOperationProps, PaymentOperation, Operation, SetOperationsTypeProps } from './types';
+import { VipClub } from './entities/vipClub';
+import { AvailableBonuses } from './entities/availableBonuses';
+import { ActiveBonuses } from './entities/activeBonuses';
+import { UserOperationServices } from './services';
+import { TournamentOperations } from './entities/tournaments';
+import { CallbackStatus, SendCommand } from 'socket/types';
+import { ReferralOperation } from './entities/referralOperations';
+import { ObservableEntity } from 'service/observableEntity';
+import { UpdateData } from 'service/observable/type';
+import { CashBonuses } from './entities/cashBonuses';
+import { CasinoHistoryBet } from './entities/casinoHistory/types';
+import { ResponseAdapterService } from 'service/responseAdapter/services';
+export declare class UserOperations extends ObservableEntity<undefined> {
+    availableBonuses: AvailableBonuses;
+    activeBonuses: ActiveBonuses;
+    services: UserOperationServices;
+    parentService: ResponseAdapterService;
+    payments: Payments;
+    casinoGames: CasinoGames;
+    cashBonuses: CashBonuses;
+    vipClub: VipClub;
+    tournaments: TournamentOperations;
+    referralOperations: ReferralOperation;
+    availableBonusOnDeposit: Operation[];
+    availableFreeSpins: Operation[];
+    activeBonusOnDeposit: Operation[];
+    activeFreeSpins: Operation[];
+    casinoGameHistoryCallbackFn: ((o: CasinoHistoryBet[]) => void)[];
+    sendCommand: SendCommand;
+    callbackStatus: CallbackStatus;
+    constructor(sendCommand: SendCommand, callbackStatus: CallbackStatus, parentService: ResponseAdapterService);
+    reset(): void;
+    setPaymentOperations(operations: PaymentOperation[]): void;
+    saveGameCasinoOperation(games: CasinoHistoryBet[]): void;
+    setOperations(result: SetOperationsTypeProps): void;
+    addCasinoGameOperations(games: CasinoHistoryBet[]): void;
+    updateCurrentOperations(operations: Operation[]): void;
+    updateOperations(operations: Operation[]): void;
+    cancelOperation(result: CancelOperationProps): void;
+    private updateAvailableBonuses;
+    sendUpdateEntity(updateConfig: SubscribeComposeTransactionsProps): UpdateData | null;
+    forceUpdate(): void;
+    subscribeTableTransactions(props: SubscribeComposeTransactionsProps): void;
+    resetAllOperations(): void;
+}

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

@@ -0,0 +1,17 @@
+import { UserOperations } from '..';
+import { MixerTransactionResponse } from '../types';
+export declare class UserOperationServices {
+    parent: UserOperations;
+    constructor(parent: UserOperations);
+    handleDepositOperations(): MixerTransactionResponse;
+    handleReferralOperations(): MixerTransactionResponse;
+    handleWithdraw(): MixerTransactionResponse;
+    handleCasinoBets(withGameInfo?: boolean): MixerTransactionResponse;
+    handleRakebackOperation(isHistory?: boolean): MixerTransactionResponse;
+    handleNewVipLevel(): MixerTransactionResponse;
+    handleEgtOperation(): MixerTransactionResponse;
+    handleSupportBonusCash(): MixerTransactionResponse;
+    handleWeekly(isActive?: boolean): MixerTransactionResponse;
+    handleMonthly(isActive?: boolean): MixerTransactionResponse;
+    handleTournamentOperation(isActive?: boolean): MixerTransactionResponse;
+}