@truelab/truelogic-plinko 0.0.1-0

package/dist/types/src/shared/lib/tests/utils/getPreloadedState.d.ts

@@ -0,0 +1,345 @@
+export declare const getPreloadedState: (storePartial?: DeepPartial<TRootState>) => {
+    viewPort: import("../../../viewPort/lib/types").TViewPortState;
+    loading: {
+        config: import("../../../model/loading").TLoadingConfig;
+        gameLoadingProgress: number;
+        imagesLoadingProgress: number;
+        areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
+        isFinishedAnimation: boolean;
+        isPreloadNonCriticalSuccess: boolean;
+        isPreloadPanelSuccess: boolean;
+        isWaitingSuccess: boolean;
+        isImagesLoadingFinished: boolean;
+        isGameLoadingStarted: boolean;
+        isLoadingAssetsPreloaded: boolean;
+        nonCriticalImagesToLoad: number;
+        nonCriticalImagesLoaded: number;
+        panelImagesToLoad: number;
+        panelImagesLoaded: number;
+    };
+    welcome: {
+        config: import("../../../model/welcome").TWelcomeConfig;
+    };
+    apiConfig: import("../../../../app/config/types/apiConfig").TApiConfigState;
+    stake: import("../../../../entities/stake/model/stakeSlice").TStakeState;
+    autoPlay: {
+        isActive: boolean;
+        isAvailable?: boolean;
+        lossLimitTotal: number;
+        inProgress: boolean;
+        isVisibleDropdown: boolean;
+        activeNumber?: number;
+        startNumber?: number;
+        activeIndex?: number;
+        autospinNumbers?: number[];
+        defaultAutoSpinNumber?: number;
+        lossLimitsNumbers?: number[];
+        singleWinNumbers?: number[];
+        stopInBonusGame: boolean;
+        lossLimit?: {
+            active: boolean;
+            value: number;
+            customValue: string;
+        };
+        singleWin?: {
+            active: boolean;
+            value: number;
+            customValue: string;
+        };
+        delay?: {
+            default: number;
+            fastPlay?: number;
+        };
+    };
+    session: {
+        isDemo: boolean;
+        partner: string;
+        balance: number;
+        balancePrevious: number;
+        netValue: number;
+        netValuePrevious: number;
+        shouldResetNetValue: boolean;
+        currency: string;
+        currencyDecimals: number;
+        urls: import("../../../api/config/types").TSessionUrls;
+    };
+    modals: {
+        hasOpened: boolean;
+        current: import("../../../model/modals").TModalName[];
+        configs: {
+            menu: import("../../../model/menu").TMenuConfig;
+        };
+        isModalReady: boolean;
+        serviceErrorName: string;
+        serviceErrorMessage: string;
+        serviceAutoplayType: import("../../../../entities/autoplay").TAutoplayServiceModalType;
+    };
+    app: {
+        screen: import("../../../model/app/appSlice").TScreen;
+        isReplay: boolean;
+        isUIHidden: boolean;
+        isOffline: boolean;
+        urlParams: {
+            isHomeButtonDisabled: boolean;
+        };
+        env: {
+            isDev: boolean;
+            isStaging: boolean;
+            isProd: boolean;
+        };
+        error: import("../../../model/app").TAppError;
+        isTestAvailable: boolean;
+        test: string;
+        isUIFrozen: boolean;
+        isIframe: boolean;
+        isBonusActive: boolean;
+        tapAnywhere: {
+            enabled: boolean;
+            type: import("../../../model/app/appSlice").TTapAnywhereType;
+            autocloseDelay: number;
+        };
+        startSessionTime?: number;
+    };
+    sound: {
+        isActive: boolean;
+        isDragging: boolean;
+        isChangedByUser: boolean;
+        lastOffParam: "effects" | "music" | null;
+        volume: {
+            current: number;
+            store: number;
+        };
+        effects: {
+            current: number;
+            store: number;
+        };
+        music: {
+            current: number;
+            store: number;
+        };
+    };
+    play: {
+        isActive: boolean;
+    };
+    apiRoundOpen: {
+        data: import("../../../api/round/open").TApiRoundOpenResponse;
+        isPending: boolean;
+        error: {
+            name: string;
+            message: string;
+        };
+        fake: import("../../../api/round/open").TApiRoundOpenFake;
+    };
+    fastPlay: {
+        isActive: boolean;
+    };
+    bonus: {
+        modes: import("../../../model/bonus").TBonusModes;
+        hasBonusGame: boolean;
+        currentModeNames: string[];
+        selectedModeName: string;
+        preselectedModeName: string;
+        isConfirmModalShown: boolean;
+        tmpLevel: number;
+        tmpAmountIndex: number;
+        activeSlideWidth: number;
+        activeSlideOffsetX: number;
+        isSliderInTransition: boolean;
+        isSliderInSwiping: boolean;
+        isOutsideViewportCardSelected: boolean;
+        isLastSlideOutOfView: boolean;
+    };
+    realityCheck: {
+        isActive: boolean;
+        isActiveToggle: boolean;
+        isActiveReminder: boolean;
+        isPausedActive: boolean;
+        timeValues: number[];
+        repeatTimeValues: number[];
+        hasDeferred: boolean;
+        startRepeatReminderTime: number;
+        startReminderTime: number;
+        delayTime: number;
+        reminderTime?: {
+            new?: {
+                value: number;
+                customValue: number;
+            };
+            current: {
+                value: number;
+                customValue: number;
+            };
+        };
+        repeatReminderTime?: {
+            new?: {
+                value: number;
+                customValue: number;
+            };
+            current?: {
+                value: number;
+                customValue: number;
+            };
+        };
+    };
+    skip: {
+        isEnabled: boolean;
+        isTurboActive: boolean;
+        turboRoundsDelay: number;
+        turboSkipDelay: number;
+        isTooltipActive: boolean;
+        shouldOpenTooltip: boolean;
+        tooltipCheckpoint: number;
+        isSkipCounterEnabled: boolean;
+        skipCounter: number;
+    };
+    round: {
+        roundId: string;
+        meta?: unknown;
+        responsesGS: import("../../../../truelogic").TResponseGS[];
+        isRestore: boolean;
+        wasRestore: boolean;
+        hasMaxWin: boolean;
+        current: {
+            responseGS: import("../../../../truelogic").TResponseGS;
+            responseGSIndex: number;
+            isFinished: boolean;
+            win: import("../../../../entities/round").TWin;
+            choice?: number;
+        };
+        final: {
+            balance: number;
+            winCash: number;
+        };
+    };
+    panel: {
+        config: import("../../../model/panels").TPanelConfig;
+        counterData: import("../../../model/panels").TPanelCounterData;
+    };
+    localization: import("../../../localization").TLocalizationSettings;
+    payTable: {
+        containers: import("../../../../entities/payTable").TPayTableContainer[];
+        symbolsGridV1Gap: import("../../../../entities/payTable").TSymbolsGridV1Gap;
+        background?: string | {
+            portrait?: string;
+            landscape?: string;
+        };
+    };
+    apiRoundClose: {
+        data: import("../../../api/round/close").TApiRoundCloseResponse;
+        isPending: boolean;
+        error: {
+            name: string;
+            message: string;
+        };
+        fake: import("../../../api/round/close").TApiRoundCloseFake;
+    };
+    roundsHistory: {
+        isPending: boolean;
+        error: import("../../../../entities/roundsHistory/model/roundsHistorySlice").TRoundsHistoryError;
+        rounds: import("../../../api/roundsHistory").THistoryRoundData[];
+        selectedRoundUUID: string;
+        replayRound: {
+            date: string;
+            replayUrl: string;
+            bet: number;
+            win: number;
+        };
+        replayStatus: "start" | "end";
+        fake: import("../../../api/roundsHistory").TApiRoundsHistoryFake;
+    };
+    gameInfo: {
+        deferredConfig: import("../../../../truelogic").TGameInfoConfig;
+        containers: import("../../../ui/InfoConstructor").TInfoContainer[];
+        background?: string | {
+            portrait?: string;
+            landscape?: string;
+        };
+        preset?: import("../../../../entities/gameInfo").TGameInfoPreset;
+    };
+    apiRoundPlay: {
+        data: import("../../../api/round/play").TApiRoundPlayResponse;
+        isPending: boolean;
+        error: {
+            name: string;
+            message: string;
+        };
+        fake: import("../../../api/round/play").TApiRoundPlayFake;
+    };
+    freeRounds: {
+        isActive: boolean;
+        displayCount: number;
+        displayTotalWon: number;
+        current: import("../../../api/round/open").TPromoTool;
+        initial: import("../../../api/round/open").TPromoTool;
+        version: `${import("../../types/theme").EVersion}`;
+    };
+    apiRoundReplay: import("../../../../app/config/types/apiRoundReplay").TApiRoundReplayState;
+    gameSettings: import("../../../api/config").TGameSettings;
+    complianceSettings: import("../../../api/config").TComplianceSettings;
+    fullScreen: {
+        isFullScreenSupported: boolean;
+        isFullScreenEnabled: boolean;
+    };
+    topLine: {
+        config: import("../../../model/topLine").TTopLineConfig;
+    };
+    fillFrame: {
+        config: {
+            enabled: boolean;
+            portrait?: {
+                width: number;
+                height: number;
+            };
+            landscape?: {
+                width: number;
+                height: number;
+            };
+        };
+    };
+    prizeDrop: {
+        campaign?: import("../../../model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../../../model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListFake;
+        };
+        apiJoinCampaign: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+        };
+        apiSocketCredentials: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
+        };
+        socketConnection?: {
+            data: null;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../sockets").TSocketPrizeDropFake;
+        } & {
+            isSuccess: boolean;
+        };
+        restData?: import("../../../api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
+        defferedCampaign?: import("../../../sockets").TPrizeDropSocketEventPayloadCampaignUpdated;
+    };
+} & import("redux-persist/es/persistReducer").PersistPartial;

package/dist/types/src/shared/lib/tests/utils/renderComponent.d.ts

@@ -0,0 +1,5 @@
+import { RenderOptions } from '@testing-library/react';
+import { ReactElement } from 'react';
+export declare const renderComponent: (ui: ReactElement, { storePartial, ...renderOptions }?: {
+    storePartial?: DeepPartial<TRootState>;
+} & RenderOptions) => import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;