@betorigami/games 2.9.0 → 2.9.2

package/dist/index.d.ts

@@ -7389,18 +7389,49 @@ declare abstract class GameComponent extends OrigamiElement {
 	protected autobetStopping: boolean;
 	static styles: import("lit").CSSResult[];
 	protected onBetAmountChange: (_oldBetAmount: string, _newBetAmount: string) => void;
+	private deferredBetReset;
 	private gameConsumer;
 	get gameData(): gameContextType;
 	get isDemoMode(): boolean;
 	get isToggleDisabled(): boolean;
 	get areInputsDisabled(): boolean;
+	/**
+	 * Instant bets settle in a single step, with no reveal animation to cover the wait on the provider.
+	 * Read live rather than pinned for the round: the animators decide the same way, several of them
+	 * straight from the context, and a reveal they skip is one the round would wait on for good.
+	 */
+	protected get isInstantBet(): boolean;
 	protected getDelay(normalDelay: number): number;
 	protected forceUIUpdate(): Promise<void>;
 	protected executeInstantOrAnimated<T>(instantOperation: () => Promise<T> | T, animatedOperation: () => Promise<T> | T): Promise<T>;
 	/**
-	 * @deprecated Use sleep instead
+	 * Clears the previous round so the next one starts from a blank board. An instant bet has no reveal
+	 * animation to fill the wait on the provider, so the reset is held back until the response lands and
+	 * the previous result stays up instead of the board sitting empty for the length of the request.
+	 */
+	protected resetForNextBet(reset: () => void): void;
+	/**
+	 * Places a bet, applying any reset held back by resetForNextBet once the provider has responded and
+	 * before the round's result is applied.
+	 */
+	protected placeBet<T>(request: () => Promise<T>): Promise<T>;
+	/**
+	 * Drops the stake from the displayed balance so it moves as the reveal animation starts. An instant
+	 * bet settles in one step, so the balance is left alone rather than dipping for however long the
+	 * provider takes to respond and then jumping to the settled value.
+	 */
+	protected preDeductStake(balanceBeforeBet: Big$1, stake: Big$1.BigSource): void;
+	/**
+	 * Lets an animated reveal settle before the result counts as shown, since the outcome lands a beat
+	 * after the cards or tiles come to rest and a win takes a beat longer again to register.
+	 */
+	protected awaitRevealSettle(hasWon: boolean): Promise<void>;
+	/**
+	 * Holds the round's result on screen long enough to be read before the next round replaces it. The
+	 * hold runs from the point the result is painted rather than from the start of the round, so the wait
+	 * on the provider does not eat into it the way a round wide budget does once latency is real.
 	 */
-	protected ensureMinimumDisplayTime(hasWin?: boolean, winDisplayTime?: number, lossDisplayTime?: number): Promise<void>;
+	protected holdResultDisplay(): Promise<void>;
 	disconnectedCallback(): void;
 	toggleAutobet(event: AutobetToggleEvent): Promise<void>;
 	protected abstract executeAutobet(autobetSettings: AutobetSettingsWithId, currentBetAmount: string): Promise<GameBetResult>;
@@ -7748,6 +7779,7 @@ export declare class LimboGame extends GameComponent {
 	limboPlay(): Promise<void>;
 	private handleBetExecution;
 	private static readonly ANIMATION_TIMEOUT_MS;
+	private awaitRevealAnimation;
 	private waitForAnimationComplete;
 	private isSpacebarDisabled;
 	private handleSpacebar;
@@ -8091,7 +8123,6 @@ export declare class RouletteGame extends ChipTableGameComponent {
 	private addToHistory;
 	private extractHitNumberFromActions;
 	private applyBetResult;
-	private waitForAutobetDisplay;
 	private handleBetExecution;
 	private handleBallLand;
 	roulettePlay(): Promise<void>;