@duyquangnvx/spindle 1.0.0-beta.1 → 1.0.0-beta.2

package/README.md

@@ -14,7 +14,6 @@ Subpath exports:
 
 ```ts
 import { createSpindle } from "@jagaming/spindle";           // core engine
-import { createSlotRenderer } from "@jagaming/spindle/renderer"; // abstract renderer
 import { recording } from "@jagaming/spindle/testing";          // test utilities
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@duyquangnvx/spindle",
-	"version": "1.0.0-beta.1",
+	"version": "1.0.0-beta.2",
 	"description": "Headless TypeScript slot engine",
 	"type": "module",
 	"main": "./dist/index.cjs",
@@ -26,19 +26,11 @@
 				"types": "./dist/testing/index.d.cts",
 				"default": "./dist/testing/index.cjs"
 			}
-		},
-		"./renderer": {
-			"import": {
-				"types": "./dist/renderer/index.d.mts",
-				"default": "./dist/renderer/index.mjs"
-			},
-			"require": {
-				"types": "./dist/renderer/index.d.cts",
-				"default": "./dist/renderer/index.cjs"
-			}
 		}
 	},
-	"files": ["dist"],
+	"files": [
+		"dist"
+	],
 	"scripts": {
 		"build": "tsdown",
 		"dev": "tsdown --watch",
@@ -50,7 +42,11 @@
 		"clean": "rm -rf dist",
 		"prepublishOnly": "npm run build"
 	},
-	"keywords": ["slot", "game", "engine"],
+	"keywords": [
+		"slot",
+		"game",
+		"engine"
+	],
 	"license": "UNLICENSED",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.0",
@@ -58,4 +54,4 @@
 		"typescript": "^5.7.0",
 		"vitest": "^4.0.18"
 	}
-}
+}

package/dist/renderer/index.cjs

@@ -1,548 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_types = require('../types-NL78Eg3j.cjs');
-
-//#region src/renderer/timeout.ts
-function withTimeout(promise, ms, label) {
-	if (ms <= 0 || !Number.isFinite(ms)) return promise;
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			reject(/* @__PURE__ */ new Error(`Timeout: ${label} exceeded ${ms}ms`));
-		}, ms);
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}, (err) => {
-			clearTimeout(timer);
-			reject(err);
-		});
-	});
-}
-
-//#endregion
-//#region src/renderer/scenes/free-spins-scene.ts
-var FreeSpinsScene = class {
-	scene;
-	hud;
-	timeout;
-	constructor(scene, hud, timeout) {
-		this.scene = scene;
-		this.hud = hud;
-		this.timeout = timeout;
-	}
-	async onFreeSpinsEnter(data) {
-		await withTimeout(this.scene.transitionTo("freeSpins"), this.timeout, "SceneView.transitionTo(freeSpins)");
-		this.hud.showFeatureCounter(0, data.totalSpins);
-	}
-	async onFreeSpinStart(data) {
-		this.hud.showFeatureCounter(data.currentSpin, data.totalSpins);
-	}
-	async onFreeSpinsRetrigger(data) {
-		this.hud.showFeatureCounter(data.totalSpins - data.added, data.totalSpins);
-	}
-	async onFreeSpinsExit(data) {
-		await withTimeout(this.hud.animateWinCounter(0, data.totalWin), this.timeout, "HUD.animateWinCounter(freeSpinsExit)");
-		await withTimeout(this.scene.transitionTo("base"), this.timeout, "SceneView.transitionTo(base)");
-	}
-};
-
-//#endregion
-//#region src/renderer/scenes/hold-and-spin-scene.ts
-var HoldAndSpinScene = class {
-	scene;
-	hud;
-	gridManager;
-	timeout;
-	constructor(scene, hud, gridManager, timeout) {
-		this.scene = scene;
-		this.hud = hud;
-		this.gridManager = gridManager;
-		this.timeout = timeout;
-	}
-	async onHoldAndSpinEnter(data) {
-		await withTimeout(this.scene.transitionTo("holdAndSpin"), this.timeout, "SceneView.transitionTo(holdAndSpin)");
-		this.hud.showFeatureCounter(0, data.totalRounds);
-		for (const locked of data.lockedSymbols) this.gridManager.getSymbolAt(locked.position.reel, locked.position.row).setSticky(true);
-	}
-	async onHoldAndSpinRound(data) {
-		this.hud.showFeatureCounter(data.round, data.round + data.remaining);
-		for (const locked of data.newLocked) this.gridManager.getSymbolAt(locked.position.reel, locked.position.row).setSticky(true);
-	}
-	async onHoldAndSpinExit(data) {
-		await withTimeout(this.hud.animateWinCounter(0, data.totalWin), this.timeout, "HUD.animateWinCounter(holdAndSpinExit)");
-		await withTimeout(this.scene.transitionTo("base"), this.timeout, "SceneView.transitionTo(base)");
-	}
-};
-
-//#endregion
-//#region src/renderer/delegate-builder.ts
-var DelegateBuilder = class {
-	views;
-	systems;
-	gridManager;
-	timeout;
-	constructor(views, systems, gridManager, timeout) {
-		this.views = views;
-		this.systems = systems;
-		this.gridManager = gridManager;
-		this.timeout = timeout;
-	}
-	build() {
-		const delegate = {};
-		this.wireCore(delegate);
-		this.wireReels(delegate);
-		if (this.systems.winPresenter) this.wireWins(delegate, this.systems.winPresenter);
-		if (this.systems.wildPresenter) this.wireWilds(delegate, this.systems.wildPresenter);
-		if (this.systems.cascadeOrchestrator) this.wireCascade(delegate, this.systems.cascadeOrchestrator);
-		if (this.systems.scatterPresenter) this.wireScatter(delegate, this.systems.scatterPresenter);
-		this.wireCelebrations(delegate);
-		this.wireSymbolTransform(delegate);
-		this.wireFeatureScenes(delegate);
-		this.wireBonusViews(delegate);
-		return delegate;
-	}
-	wireCore(delegate) {
-		const { hud, server } = this.views;
-		const timeout = this.timeout;
-		delegate.onSpinStart = async () => {
-			hud.lock();
-		};
-		delegate.onSpinEnd = async (data) => {
-			hud.unlock();
-			if (data.totalWin > 0) await withTimeout(hud.animateWinCounter(0, data.totalWin), timeout, "HUD.animateWinCounter");
-		};
-		delegate.requestSpinResult = async (context) => {
-			return server.spin(context);
-		};
-	}
-	wireReels(delegate) {
-		const { reelSystem } = this.systems;
-		const gm = this.gridManager;
-		delegate.presentReelStop = async (data) => {
-			await reelSystem.handleReelStop(data, gm);
-		};
-		delegate.presentAnticipation = async (data) => {
-			await reelSystem.handleAnticipation(data);
-		};
-	}
-	wireWins(delegate, wp) {
-		const gm = this.gridManager;
-		const present = async (data) => {
-			const { mode, metadata, ...win } = data;
-			await wp.presentWin(win, gm, {
-				mode,
-				metadata
-			});
-		};
-		delegate.presentWaysWin = present;
-		delegate.presentPaylineWin = present;
-		delegate.presentClusterWin = present;
-	}
-	wireWilds(delegate, wild) {
-		const gm = this.gridManager;
-		delegate.presentExpandingWild = async (data) => {
-			await wild.handleExpandingWild(data, gm);
-		};
-		delegate.presentStickyWild = async (data) => {
-			await wild.handleStickyWild(data, gm);
-		};
-		delegate.presentWalkingWild = async (data) => {
-			await wild.handleWalkingWild(data, gm);
-		};
-		delegate.presentStackedWild = async (data) => {
-			await wild.handleStackedWild(data, gm);
-		};
-		delegate.presentMultiplierWild = async (data) => {
-			await wild.handleMultiplierWild(data, gm);
-		};
-		delegate.presentRandomWild = async (data) => {
-			await wild.handleRandomWild(data, gm);
-		};
-	}
-	wireCascade(delegate, cascade) {
-		const gm = this.gridManager;
-		delegate.presentCascadeDestroy = async (data) => {
-			await cascade.handleDestroy(data, gm);
-		};
-		delegate.presentCascadeDrop = async (data) => {
-			await cascade.handleDrop(data, gm);
-		};
-		delegate.presentCascadeFill = async (data) => {
-			await cascade.handleFill(data, gm);
-		};
-	}
-	wireScatter(delegate, scatter) {
-		const gm = this.gridManager;
-		delegate.presentScatterWin = async (data) => {
-			await scatter.handleScatterWin(data, gm);
-		};
-	}
-	wireCelebrations(delegate) {
-		const { celebration } = this.views;
-		const { hud } = this.views;
-		const timeout = this.timeout;
-		delegate.presentBigWin = async (data) => {
-			await withTimeout(celebration.playBigWin(data.tier, data.amount), timeout, "CelebrationView.playBigWin");
-		};
-		delegate.presentJackpotTrigger = async (data) => {
-			await withTimeout(celebration.playJackpot(data.tier, data.amount), timeout, "CelebrationView.playJackpot");
-		};
-		delegate.onJackpotAwarded = async (data) => {
-			await withTimeout(hud.animateWinCounter(0, data.amount), timeout, "HUD.animateWinCounter(jackpot)");
-		};
-	}
-	wireFeatureScenes(delegate) {
-		const freeSpins = new FreeSpinsScene(this.views.scene, this.views.hud, this.timeout);
-		const holdAndSpin = new HoldAndSpinScene(this.views.scene, this.views.hud, this.gridManager, this.timeout);
-		delegate.onFreeSpinsEnter = async (data) => {
-			await freeSpins.onFreeSpinsEnter(data);
-		};
-		delegate.onFreeSpinStart = async (data) => {
-			await freeSpins.onFreeSpinStart(data);
-		};
-		delegate.onFreeSpinsRetrigger = async (data) => {
-			await freeSpins.onFreeSpinsRetrigger(data);
-		};
-		delegate.onFreeSpinsExit = async (data) => {
-			await freeSpins.onFreeSpinsExit(data);
-		};
-		delegate.onHoldAndSpinEnter = async (data) => {
-			await holdAndSpin.onHoldAndSpinEnter(data);
-		};
-		delegate.onHoldAndSpinRound = async (data) => {
-			await holdAndSpin.onHoldAndSpinRound(data);
-		};
-		delegate.onHoldAndSpinExit = async (data) => {
-			await holdAndSpin.onHoldAndSpinExit(data);
-		};
-	}
-	wireSymbolTransform(delegate) {
-		const gm = this.gridManager;
-		const timeout = this.timeout;
-		delegate.presentSymbolTransform = async (data) => {
-			for (const t of data.transforms) await withTimeout(gm.getSymbolAt(t.position.reel, t.position.row).transform(t.to), timeout, `SymbolView.transform at reel:${t.position.reel} row:${t.position.row}`);
-		};
-	}
-	wireBonusViews(delegate) {
-		const { pickBonus, wheelBonus, gamble, server } = this.views;
-		const timeout = this.timeout;
-		delegate.onPickBonusEnter = async (data) => {
-			await withTimeout(pickBonus.show(data.itemCount), timeout, "PickBonusView.show");
-		};
-		delegate.requestPickChoice = async (_data) => {
-			return { choiceIndex: await withTimeout(pickBonus.waitForPick(), timeout, "PickBonusView.waitForPick") };
-		};
-		delegate.requestPickReveal = async (data) => {
-			if (!server.pickReveal) throw new Error("ServerAdapter.pickReveal() not implemented");
-			return server.pickReveal(data);
-		};
-		delegate.presentPickReveal = async (data) => {
-			await withTimeout(pickBonus.revealItem(data.choiceIndex, data.prize), timeout, "PickBonusView.revealItem");
-		};
-		delegate.onPickBonusExit = async (_data) => {
-			await withTimeout(pickBonus.hide(), timeout, "PickBonusView.hide");
-		};
-		delegate.onWheelBonusEnter = async (data) => {
-			await withTimeout(wheelBonus.show(data.segments), timeout, "WheelBonusView.show");
-		};
-		delegate.requestWheelSpinResult = async (data) => {
-			if (!server.wheelSpin) throw new Error("ServerAdapter.wheelSpin() not implemented");
-			return server.wheelSpin(data);
-		};
-		delegate.presentWheelResult = async (data) => {
-			await withTimeout(wheelBonus.spinTo(data.segmentIndex), timeout, "WheelBonusView.spinTo");
-		};
-		delegate.onWheelBonusExit = async (_data) => {
-			await withTimeout(wheelBonus.hide(), timeout, "WheelBonusView.hide");
-		};
-		delegate.onGambleStart = async (data) => {
-			await withTimeout(gamble.show(data.currentWin), timeout, "GambleView.show");
-		};
-		delegate.requestGambleChoice = async (_data) => {
-			return withTimeout(gamble.waitForChoice(), timeout, "GambleView.waitForChoice");
-		};
-		delegate.requestGambleResult = async (data) => {
-			if (!server.gambleResult) throw new Error("ServerAdapter.gambleResult() not implemented");
-			return server.gambleResult(data);
-		};
-		delegate.presentGambleResult = async (data) => {
-			await withTimeout(gamble.revealResult(data), timeout, "GambleView.revealResult");
-		};
-		delegate.onGambleEnd = async (_data) => {
-			await withTimeout(gamble.hide(), timeout, "GambleView.hide");
-		};
-	}
-};
-
-//#endregion
-//#region src/renderer/systems/cascade-orchestrator.ts
-var DefaultCascadeOrchestrator = class {
-	timeout;
-	destroyedPositions = /* @__PURE__ */ new Set();
-	constructor(timeout) {
-		this.timeout = timeout;
-	}
-	async handleDestroy(data, gridManager) {
-		for (const pos of data.positions) this.destroyedPositions.add(`${pos.reel},${pos.row}`);
-		const destroyPromises = data.positions.map((pos) => {
-			return withTimeout(gridManager.getSymbolAt(pos.reel, pos.row).destroy(), this.timeout, `SymbolView.destroy at reel:${pos.reel} row:${pos.row}`);
-		});
-		await Promise.all(destroyPromises);
-	}
-	async handleDrop(_data, _gridManager) {}
-	async handleFill(data, gridManager) {
-		for (let reel = 0; reel < data.grid.length; reel++) for (let row = 0; row < data.grid[reel].length; row++) {
-			const key = `${reel},${row}`;
-			if (this.destroyedPositions.has(key)) gridManager.replaceSymbol(reel, row, data.grid[reel][row]);
-			else gridManager.updateSymbol(reel, row, data.grid[reel][row]);
-		}
-		this.destroyedPositions.clear();
-	}
-};
-
-//#endregion
-//#region src/renderer/systems/defaults.ts
-const noopSceneView = { async transitionTo() {} };
-const noopHUD = {
-	setBalance() {},
-	async animateWinCounter() {},
-	showFeatureCounter() {},
-	lock() {},
-	unlock() {}
-};
-const noopCelebrationView = {
-	async playBigWin() {},
-	async playJackpot() {}
-};
-const noopPickBonusView = {
-	async show() {},
-	async waitForPick() {
-		return 0;
-	},
-	async revealItem() {},
-	async hide() {}
-};
-const noopWheelBonusView = {
-	async show() {},
-	async spinTo() {},
-	async hide() {}
-};
-const noopGambleView = {
-	async show() {},
-	async waitForChoice() {
-		return { action: "collect" };
-	},
-	async revealResult() {},
-	async hide() {}
-};
-
-//#endregion
-//#region src/renderer/systems/grid-manager.ts
-var GridManager = class {
-	grid;
-	factory;
-	constructor(reels, rows, factory) {
-		this.factory = factory;
-		this.grid = [];
-		for (let r = 0; r < reels; r++) {
-			const column = [];
-			for (let row = 0; row < rows; row++) column.push(null);
-			this.grid.push(column);
-		}
-	}
-	ensureSymbol(reel, row, symbolId) {
-		const existing = this.grid[reel][row];
-		if (existing) {
-			existing.setSymbol(symbolId);
-			return existing;
-		}
-		const view = this.factory.create(symbolId, reel, row);
-		this.grid[reel][row] = view;
-		return view;
-	}
-	getSymbolAt(reel, row) {
-		const view = this.grid[reel][row];
-		if (!view) throw new Error(`No SymbolView at reel:${reel} row:${row} — grid not yet initialized`);
-		return view;
-	}
-	replaceSymbol(reel, row, newId) {
-		const old = this.grid[reel][row];
-		if (old) old.destroy();
-		const view = this.factory.create(newId, reel, row);
-		this.grid[reel][row] = view;
-		return view;
-	}
-	updateSymbol(reel, row, symbolId) {
-		this.getSymbolAt(reel, row).setSymbol(symbolId);
-	}
-	getColumn(reel) {
-		return this.grid[reel].filter((v) => v !== null);
-	}
-	forEachPosition(fn) {
-		for (let r = 0; r < this.grid.length; r++) {
-			const column = this.grid[r];
-			for (let row = 0; row < column.length; row++) {
-				const view = column[row];
-				if (view) fn(view, r, row);
-			}
-		}
-	}
-	getPositions(positions) {
-		return positions.map((p) => this.getSymbolAt(p.reel, p.row));
-	}
-	resize(reels, rowsPerReel) {
-		this.grid = [];
-		for (let r = 0; r < reels; r++) {
-			const rows = rowsPerReel[r];
-			const column = [];
-			for (let row = 0; row < rows; row++) column.push(null);
-			this.grid.push(column);
-		}
-	}
-	get reelCount() {
-		return this.grid.length;
-	}
-	getRowCount(reel) {
-		return this.grid[reel].length;
-	}
-};
-
-//#endregion
-//#region src/renderer/systems/reel-system.ts
-var DefaultReelSystem = class {
-	config;
-	timeout;
-	constructor(config, timeout) {
-		this.config = config;
-		this.timeout = timeout;
-	}
-	async handleReelStop(data, gridManager) {
-		const { reelIndex, symbols } = data;
-		for (let row = 0; row < symbols.length; row++) gridManager.ensureSymbol(reelIndex, row, symbols[row]);
-		if (this.config.stopDelay > 0) await this.delay(this.config.stopDelay);
-	}
-	async handleAnticipation(_data) {
-		if (this.config.anticipationDelay > 0) await this.delay(this.config.anticipationDelay);
-	}
-	delay(ms) {
-		return withTimeout(new Promise((resolve) => setTimeout(resolve, ms)), this.timeout, `ReelSystem.delay(${ms})`);
-	}
-};
-
-//#endregion
-//#region src/renderer/systems/scatter-presenter.ts
-var DefaultScatterPresenter = class {
-	timeout;
-	constructor(timeout) {
-		this.timeout = timeout;
-	}
-	async handleScatterWin(data, gridManager) {
-		gridManager.forEachPosition((view) => view.dim());
-		for (const pos of data.positions) gridManager.getSymbolAt(pos.reel, pos.row).undim();
-		const winPromises = data.positions.map((pos) => {
-			return withTimeout(gridManager.getSymbolAt(pos.reel, pos.row).playWin(), this.timeout, `SymbolView.playWin(scatter) at reel:${pos.reel} row:${pos.row}`);
-		});
-		await Promise.all(winPromises);
-		gridManager.forEachPosition((view) => view.playIdle());
-	}
-};
-
-//#endregion
-//#region src/renderer/systems/wild-presenter.ts
-var DefaultWildPresenter = class {
-	wildSymbolId;
-	constructor(wildSymbolId = require_types.createSymbolId("WILD")) {
-		this.wildSymbolId = wildSymbolId;
-	}
-	async handleExpandingWild(data, gridManager) {
-		for (const pos of data.expandedPositions) gridManager.getSymbolAt(pos.reel, pos.row).setSymbol(this.wildSymbolId);
-	}
-	async handleStickyWild(data, gridManager) {
-		gridManager.getSymbolAt(data.position.reel, data.position.row).setSticky(true);
-	}
-	async handleWalkingWild(data, gridManager) {
-		gridManager.getSymbolAt(data.from.reel, data.from.row).setSticky(false);
-		gridManager.getSymbolAt(data.to.reel, data.to.row).setSymbol(this.wildSymbolId);
-		gridManager.getSymbolAt(data.to.reel, data.to.row).setSticky(true);
-	}
-	async handleStackedWild(data, gridManager) {
-		for (const pos of data.positions) gridManager.getSymbolAt(pos.reel, pos.row).setSymbol(this.wildSymbolId);
-	}
-	async handleMultiplierWild(data, gridManager) {
-		const view = gridManager.getSymbolAt(data.position.reel, data.position.row);
-		view.setSymbol(this.wildSymbolId);
-		view.showMultiplier(data.multiplier);
-	}
-	async handleRandomWild(data, gridManager) {
-		for (const pos of data.positions) gridManager.getSymbolAt(pos.reel, pos.row).setSymbol(this.wildSymbolId);
-	}
-};
-
-//#endregion
-//#region src/renderer/systems/win-presenter.ts
-var DefaultWinPresenter = class {
-	timeout;
-	constructor(timeout) {
-		this.timeout = timeout;
-	}
-	async presentWin(win, gridManager, _ctx) {
-		gridManager.forEachPosition((view) => view.dim());
-		for (const pos of win.positions) gridManager.getSymbolAt(pos.reel, pos.row).undim();
-		const winPromises = win.positions.map((pos) => {
-			return withTimeout(gridManager.getSymbolAt(pos.reel, pos.row).playWin(), this.timeout, `SymbolView.playWin at reel:${pos.reel} row:${pos.row}`);
-		});
-		await Promise.all(winPromises);
-		gridManager.forEachPosition((view) => view.playIdle());
-	}
-};
-
-//#endregion
-//#region src/renderer/slot-renderer.ts
-const DEFAULT_TIMEOUT = 3e4;
-function createSlotRenderer(config) {
-	validateConfig(config);
-	const timeout = config.timeout ?? DEFAULT_TIMEOUT;
-	const { gameConfig, views, reel } = config;
-	const gridManager = new GridManager(gameConfig.reels, gameConfig.rows, views.symbolFactory);
-	return {
-		delegate: new DelegateBuilder({
-			server: views.server,
-			scene: views.scene ?? noopSceneView,
-			hud: views.hud ?? noopHUD,
-			celebration: views.celebration ?? noopCelebrationView,
-			pickBonus: views.pickBonus ?? noopPickBonusView,
-			wheelBonus: views.wheelBonus ?? noopWheelBonusView,
-			gamble: views.gamble ?? noopGambleView
-		}, {
-			reelSystem: config.overrides?.reelSystem ?? new DefaultReelSystem(reel, timeout),
-			winPresenter: config.overrides?.winPresenter ?? new DefaultWinPresenter(timeout),
-			cascadeOrchestrator: config.overrides?.cascadeOrchestrator ?? new DefaultCascadeOrchestrator(timeout),
-			wildPresenter: config.overrides?.wildPresenter ?? new DefaultWildPresenter(config.wildSymbolId),
-			scatterPresenter: config.overrides?.scatterPresenter ?? new DefaultScatterPresenter(timeout)
-		}, gridManager, timeout).build(),
-		dispose() {}
-	};
-}
-function validateConfig(config) {
-	if (!config.views.symbolFactory) throw new Error("SymbolViewFactory is required");
-	if (!config.views.server) throw new Error("ServerAdapter is required");
-	if (config.gameConfig.reels <= 0) throw new Error("Invalid reel count");
-	if (config.gameConfig.rows <= 0) throw new Error("Invalid row count");
-	if (config.timeout !== void 0 && config.timeout < 0) throw new Error("Timeout must be non-negative");
-}
-
-//#endregion
-exports.DefaultCascadeOrchestrator = DefaultCascadeOrchestrator;
-exports.DefaultReelSystem = DefaultReelSystem;
-exports.DefaultScatterPresenter = DefaultScatterPresenter;
-exports.DefaultWildPresenter = DefaultWildPresenter;
-exports.DefaultWinPresenter = DefaultWinPresenter;
-exports.GridManager = GridManager;
-exports.createSlotRenderer = createSlotRenderer;
-exports.noopCelebrationView = noopCelebrationView;
-exports.noopGambleView = noopGambleView;
-exports.noopHUD = noopHUD;
-exports.noopPickBonusView = noopPickBonusView;
-exports.noopSceneView = noopSceneView;
-exports.noopWheelBonusView = noopWheelBonusView;
-exports.withTimeout = withTimeout;
-//# sourceMappingURL=index.cjs.map