@smoregg/sdk 1.2.0 → 2.0.0

package/dist/types/controller.d.ts

@@ -1,65 +1,44 @@
 /**
  * createController - Factory function for creating a Controller instance.
  *
- * Returns a Promise that resolves when the controller is ready and initialized.
- * Uses PostMessageTransport for iframe communication with parent window.
+ * Returns a Controller instance synchronously. The controller begins listening
+ * for the bridge init message immediately. Use `.ready` to await full
+ * initialization, and `.on()` / lifecycle methods to register handlers
+ * (can be called before ready).
  *
- * @example Promise-based (recommended)
+ * @example
  * ```ts
- * const controller = await createController<MyEvents>({
- *   listeners: {
- *     'phase-update': (data) => setPhase(data.phase),
- *   },
- * });
+ * const controller = createController<MyEvents>({ debug: true });
  *
- * console.log(`Ready! My index: ${controller.myIndex}`);
- * controller.send('tap', { x: 100, y: 200 });
- * ```
+ * controller.on('phase-update', (data) => setPhase(data.phase));
+ * controller.onAllReady(() => console.log('Ready!'));
  *
- * @example Callback-based
- * ```ts
- * const controller = createController<MyEvents>({
- *   onReady: () => {
- *     console.log('Ready!');
- *   },
- *   listeners: { ... },
- * });
- * // Use controller.instance for immediate access
+ * await controller.ready;
+ * controller.send('tap', { x: 100, y: 200 });
  * ```
  */
 import type { Controller, ControllerConfig, EventMap } from './types';
 /**
  * Create a Controller instance for the player/phone side of your game.
  *
- * Returns a Promise that resolves when the controller is ready.
- * The returned object also has an `instance` property for immediate access.
+ * Returns a Controller instance synchronously. The controller begins listening
+ * for the bridge init message immediately. Register event handlers and
+ * lifecycle callbacks on the instance, then await `.ready` if needed.
  *
  * @template TEvents - Event map type for type-safe events
- * @param config - Controller configuration
- * @returns Promise that resolves to the Controller instance when ready
+ * @param config - Controller configuration (debug, parentOrigin, timeout)
+ * @returns Controller instance
  *
- * @example Promise-based (recommended)
+ * @example
  * ```ts
- * const controller = await createController<MyEvents>({
- *   listeners: {
- *     'phase-update': (data) => setPhase(data.phase),
- *   },
- * });
+ * const controller = createController<MyEvents>({ debug: true });
  *
- * controller.send('tap', { x: 100, y: 200 });
- * ```
+ * controller.on('phase-update', (data) => setPhase(data.phase));
+ * controller.onAllReady(() => console.log('Ready!'));
  *
- * @example Callback-based
- * ```ts
- * const result = createController<MyEvents>({
- *   onReady: () => {
- *     result.instance.send('ready', {});
- *   },
- *   listeners: { ... },
- * });
+ * await controller.ready;
+ * controller.send('tap', { x: 100, y: 200 });
  * ```
  */
-export declare function createController<TEvents extends EventMap = EventMap>(config?: ControllerConfig<TEvents>): Promise<Controller<TEvents>> & {
-    instance: Controller<TEvents>;
-};
+export declare function createController<TEvents extends EventMap = EventMap>(config?: ControllerConfig<TEvents>): Controller<TEvents>;
 //# sourceMappingURL=controller.d.ts.map

package/dist/types/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAIhB,QAAQ,EAIT,MAAM,SAAS,CAAC;AAosBjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAClE,MAAM,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,GACjC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;CAAE,CAUlE"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAIhB,QAAQ,EAMT,MAAM,SAAS,CAAC;AA0wBjB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAClE,MAAM,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,GACjC,UAAU,CAAC,OAAO,CAAC,CAErB"}

package/dist/types/index.d.ts

@@ -2,7 +2,7 @@
  * S'MORE Game SDK
  *
  * Pure SDK package for building party games.
- * Provides factory-based API with type-safe events.
+ * Provides event emitter pattern API with type-safe events.
  *
  * Works in any environment: React, Phaser, Vanilla JS.
  *
@@ -10,13 +10,13 @@
  * ```ts
  * import { createScreen } from '@smoregg/sdk';
  *
- * const screen = await createScreen<MyEvents>({
- *   onControllerJoin: (playerIndex) => console.log('Player joined:', playerIndex),
- *   listeners: {
- *     tap: (playerIndex, data) => handleTap(playerIndex),
- *   },
- * });
+ * const screen = createScreen<MyEvents>({ debug: true });
  *
+ * screen.on('tap', (playerIndex, data) => handleTap(playerIndex, data));
+ * screen.onAllReady(() => startGame());
+ * screen.onControllerJoin((pi, info) => console.log('Player joined:', pi));
+ *
+ * await screen.ready;
  * screen.broadcast('phase-update', { phase: 'playing' });
  * screen.gameOver({ scores: { 0: 100, 1: 50 } });
  * ```
@@ -25,13 +25,13 @@
  * ```ts
  * import { createController } from '@smoregg/sdk';
  *
- * const controller = await createController<MyEvents>({
- *   listeners: {
- *     'phase-update': (data) => handlePhase(data.phase),
- *   },
- * });
+ * const controller = createController<MyEvents>({ debug: true });
+ *
+ * controller.on('phase-update', (data) => handlePhase(data.phase));
+ * controller.onAllReady(() => console.log('Ready!'));
  *
- * console.log('Ready! My index:', controller.myIndex);
+ * await controller.ready;
+ * console.log('My index:', controller.myIndex);
  * controller.send('tap', { timestamp: Date.now() });
  * ```
  */
@@ -41,7 +41,7 @@ export { SmoreSDKError } from './errors';
 export { validateEventName } from './events';
 export { configure } from './config';
 export type { SmoreGlobalConfig } from './config';
-export type { PlayerIndex, RoomCode, EventMap, EventNames, EventData, Controller, ControllerConfig, ControllerEventHandler, ControllerListeners, ControllerInfo, CharacterAppearance, Screen, ScreenConfig, ScreenEventHandler, ScreenListeners, GameResults, SmoreError, SmoreErrorCode, LogLevel, DebugOptions, GameMetadata, } from './types';
+export type { PlayerIndex, RoomCode, EventMap, EventNames, EventData, Controller, ControllerConfig, ControllerEventHandler, ControllerInfo, CharacterAppearance, Screen, ScreenConfig, ScreenEventHandler, GameResults, SmoreError, SmoreErrorCode, LogLevel, DebugOptions, GameMetadata, } from './types';
 export { createMockScreen, createMockController } from './testing';
 export type { MockScreen, MockController, MockOptions } from './testing';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAMH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGlD,YAAY,EAEV,WAAW,EACX,QAAQ,EAER,QAAQ,EACR,UAAU,EACV,SAAS,EAET,UAAU,EACV,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EAEnB,MAAM,EACN,YAAY,EACZ,kBAAkB,EAClB,eAAe,EAEf,WAAW,EAEX,UAAU,EACV,cAAc,EAEd,QAAQ,EACR,YAAY,EAEZ,YAAY,GACb,MAAM,SAAS,CAAC;AAMjB,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACnE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAMH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGlD,YAAY,EAEV,WAAW,EACX,QAAQ,EAER,QAAQ,EACR,UAAU,EACV,SAAS,EAET,UAAU,EACV,gBAAgB,EAChB,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EAEnB,MAAM,EACN,YAAY,EACZ,kBAAkB,EAElB,WAAW,EAEX,UAAU,EACV,cAAc,EAEd,QAAQ,EACR,YAAY,EAEZ,YAAY,GACb,MAAM,SAAS,CAAC;AAMjB,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACnE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}

package/dist/types/screen.d.ts

@@ -1,66 +1,55 @@
 /**
  * createScreen - Factory function for Screen instances (Host/TV side)
  *
- * Promise-based factory with type-safe event handling and comprehensive error management.
+ * Synchronous factory with event emitter pattern. Returns a Screen instance
+ * immediately. Use `.ready` to await full initialization, and `.on()` /
+ * lifecycle methods to register handlers (can be called before ready).
  *
- * @example Promise-based (recommended)
+ * @example
  * ```ts
  * interface MyEvents {
  *   tap: { x: number; y: number };
  *   'phase-update': { phase: 'lobby' | 'playing' | 'results' };
  * }
  *
- * const screen = await createScreen<MyEvents>({
- *   listeners: {
- *     tap: (playerIndex, data) => console.log(`Player ${playerIndex} tapped at`, data.x, data.y),
- *   },
+ * const screen = createScreen<MyEvents>({ debug: true });
+ *
+ * screen.on('tap', (playerIndex, data) => {
+ *   console.log(`Player ${playerIndex} tapped at`, data.x, data.y);
  * });
  *
- * screen.broadcast('phase-update', { phase: 'playing' });
- * ```
+ * screen.onAllReady(() => startGame());
+ * screen.onControllerJoin((pi, info) => addPlayer(pi, info));
  *
- * @example Callback-based
- * ```ts
- * const screen = createScreen<MyEvents>({
- *   onReady: () => screen.broadcast('ready', {}),
- *   listeners: { ... },
- * });
- * // Use screen.instance for immediate access
+ * await screen.ready;
+ * screen.broadcast('phase-update', { phase: 'playing' });
  * ```
  */
 import type { EventMap, Screen, ScreenConfig } from './types';
 /**
  * Create a Screen instance for the host/TV side of your game.
  *
- * Returns a Promise that resolves when the screen is ready.
- * The promise also has an `instance` property for immediate access (use with onReady callback).
+ * Returns a Screen instance synchronously. The screen begins listening
+ * for the bridge init message immediately. Register event handlers and
+ * lifecycle callbacks on the instance, then await `.ready` if needed.
  *
  * @template TEvents - Event map type for type-safe events
- * @param config - Screen configuration
- * @returns Promise that resolves to the Screen instance when ready
+ * @param config - Screen configuration (debug, parentOrigin, timeout)
+ * @returns Screen instance
  *
- * @example Promise-based (recommended)
+ * @example
  * ```ts
- * const screen = await createScreen<MyEvents>({
- *   listeners: {
- *     tap: (playerIndex, data) => handleTap(playerIndex, data),
- *   },
+ * const screen = createScreen<MyEvents>({ debug: true });
+ *
+ * screen.on('tap', (playerIndex, data) => {
+ *   screen.broadcast('round-result', { winner: playerIndex });
  * });
  *
- * screen.broadcast('game-start', { countdown: 3 });
- * ```
+ * screen.onAllReady(() => startGame());
+ * screen.onControllerJoin((pi, info) => addPlayer(pi, info));
  *
- * @example Callback-based
- * ```ts
- * const { instance: screen } = createScreen<MyEvents>({
- *   onReady: () => {
- *     screen.broadcast('game-start', { countdown: 3 });
- *   },
- *   listeners: { ... },
- * });
+ * await screen.ready;
  * ```
  */
-export declare function createScreen<TEvents extends EventMap = EventMap>(config?: ScreenConfig<TEvents>): Promise<Screen<TEvents>> & {
-    instance: Screen<TEvents>;
-};
+export declare function createScreen<TEvents extends EventMap = EventMap>(config?: ScreenConfig<TEvents>): Screen<TEvents>;
 //# sourceMappingURL=screen.d.ts.map

package/dist/types/screen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../src/screen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EACV,QAAQ,EAGR,MAAM,EACN,YAAY,EAMb,MAAM,SAAS,CAAC;AA6wBjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,YAAY,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAC9D,MAAM,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,GAC7B,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,CAAA;CAAE,CAU1D"}
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../src/screen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EACV,QAAQ,EAGR,MAAM,EACN,YAAY,EAQb,MAAM,SAAS,CAAC;AA8zBjB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,YAAY,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAC9D,MAAM,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,GAC7B,MAAM,CAAC,OAAO,CAAC,CAEjB"}

package/dist/types/testing.d.ts

@@ -4,6 +4,10 @@
  * Mock implementations of Screen and Controller for unit testing.
  * All methods work synchronously for predictable test execution.
  *
+ * Mocks use the same event emitter pattern as the real implementations:
+ * lifecycle callbacks are registered via methods (onAllReady, onControllerJoin, etc.)
+ * on the returned instance rather than via config options.
+ *
  * @packageDocumentation
  */
 import type { EventMap, MockScreen, MockController, MockOptions } from './types';
@@ -13,6 +17,9 @@ import type { EventMap, MockScreen, MockController, MockOptions } from './types'
  * All methods work synchronously. Events can be simulated and recorded
  * for assertions in unit tests.
  *
+ * Uses the same event emitter pattern as real Screen: register lifecycle
+ * callbacks via methods on the returned instance.
+ *
  * @example
  * ```ts
  * const screen = createMockScreen<MyEvents>({
@@ -22,6 +29,9 @@ import type { EventMap, MockScreen, MockController, MockOptions } from './types'
  *   ],
  * });
  *
+ * screen.on('tap', (pi, data) => handleTap(pi, data));
+ * screen.onAllReady(() => startGame());
+ *
  * // Simulate player input
  * screen.simulateEvent(0, 'tap', { x: 100, y: 200 });
  *
@@ -39,12 +49,18 @@ export declare function createMockScreen<TEvents extends EventMap = EventMap>(op
  * All methods work synchronously. Events can be simulated and recorded
  * for assertions in unit tests.
  *
+ * Uses the same event emitter pattern as real Controller: register lifecycle
+ * callbacks via methods on the returned instance.
+ *
  * @example
  * ```ts
  * const controller = createMockController<MyEvents>({
  *   myIndex: 0,
  * });
  *
+ * controller.on('your-turn', (data) => handleTurn(data));
+ * controller.onAllReady(() => console.log('Ready!'));
+ *
  * // Simulate receiving from screen
  * controller.simulateEvent('your-turn', { timeLimit: 30 });
  *

package/dist/types/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,QAAQ,EASR,UAAU,EACV,cAAc,EACd,WAAW,EACZ,MAAM,SAAS,CAAC;AAkBjB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAClE,OAAO,GAAE,WAAgB,GACxB,UAAU,CAAC,OAAO,CAAC,CAgXrB;AAWD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EACtE,OAAO,GAAE,WAAgB,GACxB,cAAc,CAAC,OAAO,CAAC,CAiTzB;AAMD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,QAAQ,EASR,UAAU,EACV,cAAc,EACd,WAAW,EAEZ,MAAM,SAAS,CAAC;AAkBjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EAClE,OAAO,GAAE,WAAgB,GACxB,UAAU,CAAC,OAAO,CAAC,CA+WrB;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,QAAQ,GAAG,QAAQ,EACtE,OAAO,GAAE,WAAgB,GACxB,cAAc,CAAC,OAAO,CAAC,CAoSzB;AAMD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,CAAC"}