@duyquangnvx/spindle 1.0.0-beta.1

package/dist/testing/index.mjs

@@ -0,0 +1,721 @@
+import { t as createSymbolId } from "../types-B1TeoRrL.mjs";
+
+//#region src/testing/index.ts
+/**
+* Creates a test grid filled with a given symbol (or cycling through provided symbols).
+* Useful for quickly constructing grids in test scenarios.
+*/
+function createTestGrid(reels, rows, fill) {
+	const defaultSymbol = createSymbolId("T");
+	const symbols = fill ? Array.isArray(fill) ? fill : [fill] : [defaultSymbol];
+	const grid = [];
+	let idx = 0;
+	for (let r = 0; r < reels; r++) {
+		const column = [];
+		for (let row = 0; row < rows; row++) {
+			column.push(symbols[idx % symbols.length]);
+			idx++;
+		}
+		grid.push(column);
+	}
+	return grid;
+}
+/**
+* Convenience re-export of createSymbolId for test files.
+*/
+const createTestSymbolId = createSymbolId;
+function coreFragment(calls) {
+	return {
+		async onSpinStart() {
+			calls.push({
+				method: "onSpinStart",
+				data: {}
+			});
+		},
+		async presentReelStop({ reelIndex, symbols, mode, metadata }) {
+			calls.push({
+				method: "presentReelStop",
+				data: {
+					reelIndex,
+					symbols,
+					mode,
+					metadata
+				}
+			});
+		},
+		async onSpinEnd({ spinWin, featureWin, totalWin }) {
+			calls.push({
+				method: "onSpinEnd",
+				data: {
+					spinWin,
+					featureWin,
+					totalWin
+				}
+			});
+		}
+	};
+}
+function fixedDataFragment(calls, spinResult) {
+	return { async requestSpinResult(context) {
+		calls.push({
+			method: "requestSpinResult",
+			data: { context }
+		});
+		return spinResult;
+	} };
+}
+function routingDataFragment(calls, base, modeResults) {
+	let freeSpinIndex = 0;
+	let holdAndSpinIndex = 0;
+	return { async requestSpinResult(context) {
+		calls.push({
+			method: "requestSpinResult",
+			data: { context }
+		});
+		if (context.mode === "freeSpin" && modeResults.freeSpin) return modeResults.freeSpin[freeSpinIndex++];
+		if (context.mode === "holdAndSpin" && modeResults.holdAndSpin) return modeResults.holdAndSpin[holdAndSpinIndex++];
+		return base;
+	} };
+}
+function waysWinFragment(calls) {
+	return { async presentWaysWin(data) {
+		const { mode, metadata, ...win } = data;
+		calls.push({
+			method: "presentWaysWin",
+			data: {
+				win,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function paylineWinFragment(calls) {
+	return { async presentPaylineWin(data) {
+		const { mode, metadata, ...win } = data;
+		calls.push({
+			method: "presentPaylineWin",
+			data: {
+				win,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function clusterWinFragment(calls) {
+	return { async presentClusterWin(data) {
+		const { mode, metadata, ...win } = data;
+		calls.push({
+			method: "presentClusterWin",
+			data: {
+				win,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function scatterWinFragment(calls) {
+	return { async presentScatterWin(data) {
+		const { mode, metadata, ...win } = data;
+		calls.push({
+			method: "presentScatterWin",
+			data: {
+				win,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function bigWinFragment(calls) {
+	return { async presentBigWin({ tier, amount, mode, metadata }) {
+		calls.push({
+			method: "presentBigWin",
+			data: {
+				tier,
+				amount,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function anticipationFragment(calls) {
+	return { async presentAnticipation({ reelIndex, mode, metadata }) {
+		calls.push({
+			method: "presentAnticipation",
+			data: {
+				reelIndex,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function symbolTransformFragment(calls) {
+	return { async presentSymbolTransform({ transforms, mode, metadata }) {
+		calls.push({
+			method: "presentSymbolTransform",
+			data: {
+				transforms,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function cascadeFragment(calls) {
+	return {
+		async presentCascadeDestroy({ step, positions, mode, metadata }) {
+			calls.push({
+				method: "presentCascadeDestroy",
+				data: {
+					step,
+					positions,
+					mode,
+					metadata
+				}
+			});
+		},
+		async presentCascadeDrop({ step, mode, metadata }) {
+			calls.push({
+				method: "presentCascadeDrop",
+				data: {
+					step,
+					mode,
+					metadata
+				}
+			});
+		},
+		async presentCascadeFill({ step, grid, multiplier, mode, metadata }) {
+			calls.push({
+				method: "presentCascadeFill",
+				data: {
+					step,
+					grid,
+					multiplier,
+					mode,
+					metadata
+				}
+			});
+		}
+	};
+}
+function jackpotFragment(calls) {
+	return {
+		async presentJackpotTrigger({ tier, amount, mode, metadata }) {
+			calls.push({
+				method: "presentJackpotTrigger",
+				data: {
+					tier,
+					amount,
+					mode,
+					metadata
+				}
+			});
+		},
+		async onJackpotAwarded({ tier, amount, mode, metadata }) {
+			calls.push({
+				method: "onJackpotAwarded",
+				data: {
+					tier,
+					amount,
+					mode,
+					metadata
+				}
+			});
+		}
+	};
+}
+function freeSpinsFragment(calls) {
+	return {
+		async onFreeSpinsEnter({ totalSpins }) {
+			calls.push({
+				method: "onFreeSpinsEnter",
+				data: { totalSpins }
+			});
+		},
+		async onFreeSpinStart({ currentSpin, totalSpins, remaining, accumulated }) {
+			calls.push({
+				method: "onFreeSpinStart",
+				data: {
+					currentSpin,
+					totalSpins,
+					remaining,
+					accumulated
+				}
+			});
+		},
+		async onFreeSpinsRetrigger({ added, totalSpins }) {
+			calls.push({
+				method: "onFreeSpinsRetrigger",
+				data: {
+					added,
+					totalSpins
+				}
+			});
+		},
+		async onFreeSpinsExit({ totalSpins, totalWin }) {
+			calls.push({
+				method: "onFreeSpinsExit",
+				data: {
+					totalSpins,
+					totalWin
+				}
+			});
+		}
+	};
+}
+function holdAndSpinFragment(calls) {
+	return {
+		async onHoldAndSpinEnter({ totalRounds, lockedSymbols }) {
+			calls.push({
+				method: "onHoldAndSpinEnter",
+				data: {
+					totalRounds,
+					lockedSymbols
+				}
+			});
+		},
+		async onHoldAndSpinRound({ round, remaining, grid, newLocked, allLocked }) {
+			calls.push({
+				method: "onHoldAndSpinRound",
+				data: {
+					round,
+					remaining,
+					grid,
+					newLocked,
+					allLocked
+				}
+			});
+		},
+		async onHoldAndSpinExit({ totalRounds, totalWin, fullGrid }) {
+			calls.push({
+				method: "onHoldAndSpinExit",
+				data: {
+					totalRounds,
+					totalWin,
+					fullGrid
+				}
+			});
+		}
+	};
+}
+function pickBonusFragment(calls) {
+	return {
+		async onPickBonusEnter(data) {
+			calls.push({
+				method: "onPickBonusEnter",
+				data
+			});
+		},
+		async requestPickChoice(data) {
+			calls.push({
+				method: "requestPickChoice",
+				data
+			});
+			return { choiceIndex: 0 };
+		},
+		async requestPickReveal(data) {
+			calls.push({
+				method: "requestPickReveal",
+				data
+			});
+			return {
+				choiceIndex: 0,
+				prize: 0,
+				done: true
+			};
+		},
+		async presentPickReveal(data) {
+			calls.push({
+				method: "presentPickReveal",
+				data
+			});
+		},
+		async onPickBonusExit(data) {
+			calls.push({
+				method: "onPickBonusExit",
+				data
+			});
+		}
+	};
+}
+function wheelBonusFragment(calls) {
+	return {
+		async onWheelBonusEnter(data) {
+			calls.push({
+				method: "onWheelBonusEnter",
+				data
+			});
+		},
+		async requestWheelSpinResult(data) {
+			calls.push({
+				method: "requestWheelSpinResult",
+				data
+			});
+			return {
+				segmentIndex: 0,
+				prize: 0
+			};
+		},
+		async presentWheelResult(data) {
+			calls.push({
+				method: "presentWheelResult",
+				data
+			});
+		},
+		async onWheelBonusExit(data) {
+			calls.push({
+				method: "onWheelBonusExit",
+				data
+			});
+		}
+	};
+}
+function gambleFragment(calls, choices, results) {
+	let choiceIndex = 0;
+	let resultIndex = 0;
+	return {
+		async onGambleStart({ currentWin }) {
+			calls.push({
+				method: "onGambleStart",
+				data: { currentWin }
+			});
+		},
+		async requestGambleChoice({ currentWin }) {
+			const choice = choices[choiceIndex++];
+			calls.push({
+				method: "requestGambleChoice",
+				data: { currentWin }
+			});
+			return choice;
+		},
+		async requestGambleResult({ currentWin }) {
+			const result = results[resultIndex++];
+			calls.push({
+				method: "requestGambleResult",
+				data: { currentWin }
+			});
+			return result;
+		},
+		async presentGambleResult({ won, amount }) {
+			calls.push({
+				method: "presentGambleResult",
+				data: {
+					won,
+					amount
+				}
+			});
+		},
+		async onGambleEnd({ finalWin }) {
+			calls.push({
+				method: "onGambleEnd",
+				data: { finalWin }
+			});
+		}
+	};
+}
+function expandingWildFragment(calls) {
+	return { async presentExpandingWild({ position, expandedPositions, mode, metadata }) {
+		calls.push({
+			method: "presentExpandingWild",
+			data: {
+				position,
+				expandedPositions,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function stickyWildFragment(calls) {
+	return { async presentStickyWild({ position, mode, metadata }) {
+		calls.push({
+			method: "presentStickyWild",
+			data: {
+				position,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function walkingWildFragment(calls) {
+	return { async presentWalkingWild({ from, to, mode, metadata }) {
+		calls.push({
+			method: "presentWalkingWild",
+			data: {
+				from,
+				to,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function stackedWildFragment(calls) {
+	return { async presentStackedWild({ positions, mode, metadata }) {
+		calls.push({
+			method: "presentStackedWild",
+			data: {
+				positions,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function multiplierWildFragment(calls) {
+	return { async presentMultiplierWild({ position, multiplier, mode, metadata }) {
+		calls.push({
+			method: "presentMultiplierWild",
+			data: {
+				position,
+				multiplier,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function randomWildFragment(calls) {
+	return { async presentRandomWild({ positions, mode, metadata }) {
+		calls.push({
+			method: "presentRandomWild",
+			data: {
+				positions,
+				mode,
+				metadata
+			}
+		});
+	} };
+}
+function buyFeatureFragment(calls, buyTrigger) {
+	return {
+		async requestBuyFeatureResult(data) {
+			calls.push({
+				method: "requestBuyFeatureResult",
+				data
+			});
+			return buyTrigger;
+		},
+		async onBuyFeatureStart(data) {
+			calls.push({
+				method: "onBuyFeatureStart",
+				data
+			});
+		},
+		async onBuyFeatureEnd(data) {
+			calls.push({
+				method: "onBuyFeatureEnd",
+				data
+			});
+		}
+	};
+}
+var RecordingDelegateBuilder = class {
+	calls;
+	delegate;
+	constructor(calls, delegate) {
+		this.calls = calls;
+		this.delegate = delegate;
+	}
+	withWaysWin() {
+		Object.assign(this.delegate, waysWinFragment(this.calls));
+		return this;
+	}
+	withPaylineWin() {
+		Object.assign(this.delegate, paylineWinFragment(this.calls));
+		return this;
+	}
+	withClusterWin() {
+		Object.assign(this.delegate, clusterWinFragment(this.calls));
+		return this;
+	}
+	withCascade() {
+		Object.assign(this.delegate, cascadeFragment(this.calls));
+		return this;
+	}
+	withScatter() {
+		Object.assign(this.delegate, scatterWinFragment(this.calls));
+		return this;
+	}
+	withBigWin() {
+		Object.assign(this.delegate, bigWinFragment(this.calls));
+		return this;
+	}
+	withAnticipation() {
+		Object.assign(this.delegate, anticipationFragment(this.calls));
+		return this;
+	}
+	withSymbolTransform() {
+		Object.assign(this.delegate, symbolTransformFragment(this.calls));
+		return this;
+	}
+	withJackpot() {
+		Object.assign(this.delegate, jackpotFragment(this.calls));
+		return this;
+	}
+	withFreeSpins() {
+		Object.assign(this.delegate, freeSpinsFragment(this.calls));
+		return this;
+	}
+	withHoldAndSpin() {
+		Object.assign(this.delegate, holdAndSpinFragment(this.calls));
+		return this;
+	}
+	withPickBonus() {
+		Object.assign(this.delegate, pickBonusFragment(this.calls));
+		return this;
+	}
+	withWheelBonus() {
+		Object.assign(this.delegate, wheelBonusFragment(this.calls));
+		return this;
+	}
+	withWheelBonusResults(wheelResults) {
+		let idx = 0;
+		const calls = this.calls;
+		Object.assign(this.delegate, {
+			...wheelBonusFragment(calls),
+			async requestWheelSpinResult(data) {
+				calls.push({
+					method: "requestWheelSpinResult",
+					data
+				});
+				return wheelResults[idx++];
+			}
+		});
+		return this;
+	}
+	withGamble(choices, results) {
+		Object.assign(this.delegate, gambleFragment(this.calls, choices, results));
+		return this;
+	}
+	withExpandingWild() {
+		Object.assign(this.delegate, expandingWildFragment(this.calls));
+		return this;
+	}
+	withStickyWild() {
+		Object.assign(this.delegate, stickyWildFragment(this.calls));
+		return this;
+	}
+	withWalkingWild() {
+		Object.assign(this.delegate, walkingWildFragment(this.calls));
+		return this;
+	}
+	withStackedWild() {
+		Object.assign(this.delegate, stackedWildFragment(this.calls));
+		return this;
+	}
+	withMultiplierWild() {
+		Object.assign(this.delegate, multiplierWildFragment(this.calls));
+		return this;
+	}
+	withRandomWild() {
+		Object.assign(this.delegate, randomWildFragment(this.calls));
+		return this;
+	}
+	withAllWilds() {
+		Object.assign(this.delegate, expandingWildFragment(this.calls), stickyWildFragment(this.calls), walkingWildFragment(this.calls), stackedWildFragment(this.calls), multiplierWildFragment(this.calls), randomWildFragment(this.calls));
+		return this;
+	}
+	withBuyFeature(buyTrigger) {
+		Object.assign(this.delegate, buyFeatureFragment(this.calls, buyTrigger));
+		return this;
+	}
+	withPickBonusChoices(choices, reveals) {
+		let choiceIdx = 0;
+		let revealIdx = 0;
+		const calls = this.calls;
+		Object.assign(this.delegate, {
+			async onPickBonusEnter(data) {
+				calls.push({
+					method: "onPickBonusEnter",
+					data
+				});
+			},
+			async requestPickChoice(data) {
+				calls.push({
+					method: "requestPickChoice",
+					data
+				});
+				return choices[choiceIdx++];
+			},
+			async requestPickReveal(data) {
+				calls.push({
+					method: "requestPickReveal",
+					data
+				});
+				return reveals[revealIdx++];
+			},
+			async presentPickReveal(data) {
+				calls.push({
+					method: "presentPickReveal",
+					data
+				});
+			},
+			async onPickBonusExit(data) {
+				calls.push({
+					method: "onPickBonusExit",
+					data
+				});
+			}
+		});
+		return this;
+	}
+	build() {
+		return {
+			delegate: this.delegate,
+			calls: this.calls
+		};
+	}
+};
+/** Minimal recording delegate — CoreDelegate & DataDelegate only. Use .with*() to add capabilities. */
+function recording(spinResult) {
+	const calls = [];
+	return new RecordingDelegateBuilder(calls, {
+		...coreFragment(calls),
+		...fixedDataFragment(calls, spinResult)
+	});
+}
+/** Recording delegate with ways win type — covers 80% of test scenarios. */
+function recordingWays(spinResult) {
+	return recording(spinResult).withWaysWin();
+}
+/** Recording delegate with payline win type. */
+function recordingPayline(spinResult) {
+	const calls = [];
+	return new RecordingDelegateBuilder(calls, {
+		...coreFragment(calls),
+		...fixedDataFragment(calls, spinResult),
+		...paylineWinFragment(calls)
+	});
+}
+/** Recording delegate with cluster win type. */
+function recordingCluster(spinResult) {
+	const calls = [];
+	return new RecordingDelegateBuilder(calls, {
+		...coreFragment(calls),
+		...fixedDataFragment(calls, spinResult),
+		...clusterWinFragment(calls)
+	});
+}
+/** Recording delegate with mode-based routing for feature spins. */
+function recordingWithRouting(base, modeResults) {
+	const calls = [];
+	return new RecordingDelegateBuilder(calls, {
+		...coreFragment(calls),
+		...routingDataFragment(calls, base, modeResults)
+	});
+}
+/** Recording delegate with mode-based routing + ways win. */
+function recordingWaysWithRouting(base, modeResults) {
+	return recordingWithRouting(base, modeResults).withWaysWin();
+}
+
+//#endregion
+export { createTestGrid, createTestSymbolId, recording, recordingCluster, recordingPayline, recordingWays, recordingWaysWithRouting, recordingWithRouting };
+//# sourceMappingURL=index.mjs.map