@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/pipe-connect/components/GameArea.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import type { GameSettings } from '../../../services/UtilsService';
-interface GameAreaProps {
-    settings: GameSettings;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/pipe-connect/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/popit-fidget/PopitFidgetService.d.ts

@@ -1,30 +0,0 @@
-import { POPIT_FIDGET_GAME_CONFIG as GAME_CONFIG, POPIT_FIDGET_ANIMATION_CONFIG as ANIMATION_CONFIG, POPIT_FIDGET_COLORS as COLORS, BUBBLE_COLORS } from './PopitFidgetConstants';
-export { GAME_CONFIG, ANIMATION_CONFIG, COLORS, BUBBLE_COLORS };
-export interface Bubble {
-    id: string;
-    row: number;
-    col: number;
-    x: number;
-    y: number;
-    isPopped: boolean;
-    color: string;
-}
-export interface FidgetGrid {
-    size: number;
-    bubbles: Bubble[][];
-    centerX: number;
-    centerY: number;
-    width: number;
-    height: number;
-}
-export declare class PopitFidgetService {
-    private gameTimerRef;
-    constructor();
-    generateFidgetGrid(): FidgetGrid;
-    private getRainbowColorForPosition;
-    checkAllBubblesPopped(grid: FidgetGrid): boolean;
-    calculateCompletionPercentage(grid: FidgetGrid): number;
-    startGameTimer(duration: number, onTick: (timeLeft: number) => void, onComplete: () => void): void;
-    stopGameTimer(): void;
-    cleanup(): void;
-}

package/lib/typescript/src/games/popit-fidget/PopitFidgetStore.d.ts

@@ -1,33 +0,0 @@
-import type { FidgetGrid } from './PopitFidgetService';
-export interface GameState {
-    timeRemaining: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-}
-export interface PopitFidgetStore extends GameState {
-    fidgetGrid: FidgetGrid | null;
-    bubblesPopped: number;
-    totalBubbles: number;
-    score: number;
-    bubbleStates: Record<string, {
-        isPopped: boolean;
-    }>;
-    startGame: (gameDuration?: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    setFidgetGrid: (grid: FidgetGrid) => void;
-    popBubble: (row: number, col: number) => void;
-    decrementTime: () => void;
-    checkGameWon: () => void;
-    checkGameLost: () => void;
-}
-export declare const usePopitFidgetStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<PopitFidgetStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: PopitFidgetStore, previousSelectedState: PopitFidgetStore) => void): () => void;
-        <U>(selector: (state: PopitFidgetStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;

package/lib/typescript/src/games/popit-fidget/components/BubbleComponent.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { Bubble } from '../PopitFidgetService';
-interface BubbleComponentProps {
-    bubble: Bubble;
-    size: number;
-    onPop: () => void;
-    hapticEnabled?: boolean;
-}
-declare const BubbleComponent: React.NamedExoticComponent<BubbleComponentProps>;
-export default BubbleComponent;

package/lib/typescript/src/games/popit-fidget/components/FidgetGrid.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { FidgetGrid as FidgetGridType } from '../PopitFidgetService';
-interface FidgetGridProps {
-    grid: FidgetGridType;
-    bubbleSize: number;
-    onBubblePop: (row: number, col: number) => void;
-    hapticEnabled?: boolean;
-}
-declare const _default: React.NamedExoticComponent<FidgetGridProps>;
-export default _default;

package/lib/typescript/src/games/popit-fidget/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export default ScoreBoard;

package/lib/typescript/src/games/reversi/ReversiStore.d.ts

@@ -1,46 +0,0 @@
-import { type GameSettings } from '../../services/UtilsService';
-import { type ReversiPlayer, type ReversiBoard } from './ReversiConstants';
-export declare const createInitialBoard: () => ReversiBoard;
-export interface ReversiState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isTimedOut: boolean;
-    board: ReversiBoard;
-    boardVersion: number;
-    selectionVersion: number;
-    currentPlayer: ReversiPlayer;
-    validTargets: number[];
-    lastMove: number;
-    winner: ReversiPlayer | null;
-    blackCount: number;
-    whiteCount: number;
-    score: number;
-    moves: number;
-    timeLeft: number;
-    initializeGame: () => void;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    handleSelect: (index: number, settings: GameSettings) => void;
-    runAIMove: (settings: GameSettings) => void;
-    updateTime: () => void;
-}
-export declare const useReversiStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ReversiState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: ReversiState, previousSelectedState: ReversiState) => void): () => void;
-        <U>(selector: (state: ReversiState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useBoardVersion: () => number;
-export declare const useSelectionVersion: () => number;
-export declare const useCurrentPlayer: () => ReversiPlayer;
-export declare const useWinner: () => ReversiPlayer | null;
-export declare const useScore: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useBlackCount: () => number;
-export declare const useWhiteCount: () => number;

package/lib/typescript/src/games/reversi/components/GameBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface GameBoardProps {
-    onCellPress: (index: number) => void;
-}
-export declare const GameBoard: React.NamedExoticComponent<GameBoardProps>;
-export {};

package/lib/typescript/src/games/reversi/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/sliding-numbers/SlidingNumbersService.d.ts

@@ -1,6 +0,0 @@
-export declare class SlidingNumbersService {
-    private gameTimer;
-    startTimer(onTick: () => void): void;
-    stopTimer(): void;
-    cleanup(): void;
-}

package/lib/typescript/src/games/sliding-numbers/SlidingNumbersStore.d.ts

@@ -1,38 +0,0 @@
-export interface PuzzleTile {
-    id: number;
-    value: number;
-    row: number;
-    col: number;
-}
-export interface SlidingNumbersState {
-    isPlaying: boolean;
-    isCompleted: boolean;
-    isGameOver: boolean;
-    tiles: PuzzleTile[];
-    emptyRow: number;
-    emptyCol: number;
-    tilesVersion: number;
-    score: number;
-    timeLeft: number;
-    initializePuzzle: () => void;
-    moveTile: (tileId: number) => boolean;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    decrementTime: () => void;
-}
-export declare const useSlidingNumbersStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SlidingNumbersState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: SlidingNumbersState, previousSelectedState: SlidingNumbersState) => void): () => void;
-        <U>(selector: (state: SlidingNumbersState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsCompleted: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useScore: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useTilesVersion: () => number;

package/lib/typescript/src/games/sliding-numbers/components/NumbersGrid.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-interface NumbersGridProps {
-    soundEnabledRef: React.MutableRefObject<boolean>;
-    hapticEnabledRef: React.MutableRefObject<boolean>;
-}
-export declare const NumbersGrid: React.FC<NumbersGridProps>;
-export {};

package/lib/typescript/src/games/sliding-numbers/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/snake-3d/Snake3DService.d.ts

@@ -1,29 +0,0 @@
-import { type Direction } from './Snake3DConstants';
-export interface Position {
-    x: number;
-    y: number;
-}
-export interface SnakeSegment extends Position {
-    id: number;
-}
-export interface Food extends Position {
-    id: number;
-    isSpecial: boolean;
-    expiresAt?: number;
-}
-export declare class Snake3DService {
-    private nextId;
-    initializeSnake(): SnakeSegment[];
-    generateFood(snake: SnakeSegment[], isSpecial?: boolean): Food;
-    isPositionOnSnake(position: Position, snake: SnakeSegment[]): boolean;
-    moveSnake(snake: SnakeSegment[], direction: Direction): SnakeSegment[];
-    checkWallCollision(head: SnakeSegment): boolean;
-    checkSelfCollision(snake: SnakeSegment[]): boolean;
-    checkFoodCollision(head: SnakeSegment, food: Food): boolean;
-    growSnake(snake: SnakeSegment[]): SnakeSegment[];
-    isValidDirectionChange(currentDirection: Direction, newDirection: Direction): boolean;
-    getOppositeDirection(direction: Direction): Direction;
-    resetIdCounter(): void;
-    isSpecialFoodExpired(food: Food): boolean;
-    calculateScore(isSpecialFood: boolean): number;
-}

package/lib/typescript/src/games/snake-3d/Snake3DStore.d.ts

@@ -1,49 +0,0 @@
-import { type SnakeSegment, type Food } from './Snake3DService';
-import { type Direction } from './Snake3DConstants';
-import { type GameIntervalHandle } from '../../helpers/GameTimer';
-export interface Snake3DState {
-    snake: SnakeSegment[];
-    food: Food | null;
-    direction: Direction;
-    nextDirection: Direction;
-    score: number;
-    timeLeft: number;
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isPaused: boolean;
-    enableSounds: boolean;
-    enableHaptics: boolean;
-    moveTimer: GameIntervalHandle | null;
-    countdownTimer: GameIntervalHandle | null;
-    snakeVersion: number;
-    foodVersion: number;
-    lastAteFood: boolean;
-    collided: boolean;
-}
-export interface Snake3DStore extends Snake3DState {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    pauseGame: () => void;
-    resumeGame: () => void;
-    initializeGame: () => void;
-    changeDirection: (direction: Direction) => void;
-    updateSettings: (enableSounds: boolean, enableHaptics: boolean) => void;
-    gameLoop: () => void;
-    decrementTime: () => void;
-}
-export declare const useSnake3DStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<Snake3DStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: Snake3DStore, previousSelectedState: Snake3DStore) => void): () => void;
-        <U>(selector: (state: Snake3DStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useScore: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useSnakeVersion: () => number;
-export declare const useFoodVersion: () => number;

package/lib/typescript/src/games/snake-3d/components/GameGrid.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const GameGrid: React.FC;

package/lib/typescript/src/games/snake-3d/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/snakes-and-ladders/SnakesAndLaddersService.d.ts

@@ -1,22 +0,0 @@
-export interface Token {
-    id: string;
-    position: number;
-    isFinished: boolean;
-}
-export interface Player {
-    id: string;
-    color: 'blue' | 'red';
-    token: Token;
-    isAI: boolean;
-    label: string;
-}
-export type GamePhase = 'rolling' | 'moving' | 'ai_turn' | 'game_over';
-export declare const rollDice: () => number;
-export declare const createPlayers: () => Player[];
-export declare const calculateNewPosition: (currentPosition: number, diceValue: number) => number;
-export declare const isSnake: (position: number) => boolean;
-export declare const isLadder: (position: number) => boolean;
-export declare const getIntermediatePosition: (currentPosition: number, diceValue: number) => number;
-export declare const isGameFinished: (players: Player[]) => boolean;
-export declare const getWinner: (players: Player[]) => Player | null;
-export declare const calculateScore: (player: Player, allPlayers?: Player[]) => number;

package/lib/typescript/src/games/snakes-and-ladders/SnakesAndLaddersStore.d.ts

@@ -1,40 +0,0 @@
-import type { GameSettings } from '../../services/UtilsService';
-import { type Player, type GamePhase } from './SnakesAndLaddersService';
-export interface SnakesAndLaddersState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    players: Player[];
-    currentPlayerIndex: number;
-    diceValue: number | null;
-    isRolling: boolean;
-    gamePhase: GamePhase;
-    playerScore: number;
-    consecutiveSixes: number;
-    moveVersion: number;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    initializeGame: () => void;
-    rollDiceAction: (settings: GameSettings) => void;
-    makeAITurn: (settings: GameSettings) => void;
-}
-export declare const useSnakesAndLaddersStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SnakesAndLaddersState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: SnakesAndLaddersState, previousSelectedState: SnakesAndLaddersState) => void): () => void;
-        <U>(selector: (state: SnakesAndLaddersState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsWin: () => boolean;
-export declare const usePlayers: () => Player[];
-export declare const useCurrentPlayerIndex: () => number;
-export declare const useDiceValue: () => number | null;
-export declare const useIsRolling: () => boolean;
-export declare const useGamePhase: () => GamePhase;
-export declare const usePlayerScore: () => number;
-export declare const useMoveVersion: () => number;

package/lib/typescript/src/games/snakes-and-ladders/components/Dice.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-import type { GameSettings } from '../../../services/UtilsService';
-interface DiceProps {
-    settings: GameSettings;
-}
-export declare const Dice: React.FC<DiceProps>;
-export {};

package/lib/typescript/src/games/snakes-and-ladders/components/GameBoard.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const GameBoard: React.FC;

package/lib/typescript/src/games/snakes-and-ladders/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/space-fighter/SpaceFighterService.d.ts

@@ -1,117 +0,0 @@
-import { SPACE_FIGHTER_GAME_CONFIG as GAME_CONFIG, SPACE_FIGHTER_COLORS as COLORS } from './SpaceFighterConstants';
-import type { SharedValue } from 'react-native-reanimated';
-export { GAME_CONFIG, COLORS };
-export interface AsteroidSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-}
-export interface Asteroid {
-    id: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    type: 'left' | 'right';
-    pairId: string;
-    passed: boolean;
-    spawnTime: number;
-}
-export interface Spacecraft {
-    x: number;
-    y: number;
-    velocityX: number;
-    velocityY: number;
-    size: number;
-    isControlled: boolean;
-}
-export interface Particle {
-    id: string;
-    x: number;
-    y: number;
-    velocityX: number;
-    velocityY: number;
-    color: string;
-    life: number;
-    maxLife: number;
-    size: number;
-}
-declare class SpaceFighterGameService {
-    private width;
-    private height;
-    private gameTimer;
-    private asteroidSpawnTimer;
-    private physicsFrameId;
-    private particles;
-    private lastCollisionTime;
-    private currentAsteroidSpeed;
-    private currentSpawnInterval;
-    private lastPhysicsTime;
-    private asteroidSVMap;
-    private spacecraftXSV;
-    private spacecraftYSV;
-    cachedIsPlaying: boolean;
-    private _spacecraftX;
-    private _spacecraftY;
-    private _spacecraftSize;
-    private _spacecraftIsControlled;
-    private _asteroidPhysics;
-    private _onCollisionCheck;
-    constructor(screenWidth: number, screenHeight: number);
-    registerAsteroidSharedValues(id: string, sv: AsteroidSharedValues): void;
-    unregisterAsteroidSharedValues(id: string): void;
-    registerSpacecraftSharedValues(xSV: SharedValue<number>, ySV: SharedValue<number>): void;
-    setOnCollisionCheck(cb: (() => void) | null): void;
-    setPlaying(playing: boolean): void;
-    setSpacecraftPosition(x: number, y: number): void;
-    setSpacecraftControlled(controlled: boolean): void;
-    getSpacecraftX(): number;
-    getSpacecraftY(): number;
-    syncFromStore(spacecraft: Spacecraft, asteroids: Asteroid[]): void;
-    startGame(): void;
-    cleanup(): void;
-    startGameTimer(decrementTime: () => void): void;
-    updateDifficultySettings(asteroidSpeed: number, spawnInterval: number): void;
-    startAsteroidSpawning(spawnAsteroid: (asteroid: Asteroid[]) => void): void;
-    startSharedValuePhysicsLoop(onRemoveAsteroids: (removeIds: string[]) => void): void;
-    startPhysicsLoop(updateSpacecraft: (spacecraft: Spacecraft) => void, updateAsteroid: (asteroidId: string, updates: Partial<Asteroid>) => void, removeAsteroid: (asteroidId: string) => void, getSpacecraft: () => Spacecraft, getAsteroids: () => Asteroid[], batchUpdateAsteroids?: (updates: Array<{
-        id: string;
-        y: number;
-    }>, removeIds: string[]) => void): void;
-    addAsteroidsToPhysics(asteroids: Asteroid[]): void;
-    getInternalSpacecraft(): {
-        x: number;
-        y: number;
-        size: number;
-    };
-    getInternalAsteroids(): Map<string, {
-        y: number;
-        x: number;
-        width: number;
-        height: number;
-        pairId: string;
-        passed: boolean;
-    }>;
-    markAsteroidPassedInternal(pairId: string): void;
-    generateAsteroidPair(): Asteroid[];
-    updatePhysics(updateSpacecraft: (spacecraft: Spacecraft) => void, updateAsteroid: (asteroidId: string, updates: Partial<Asteroid>) => void, removeAsteroid: (asteroidId: string) => void, getSpacecraft: () => Spacecraft, getAsteroids: () => Asteroid[], batchUpdateAsteroids?: (updates: Array<{
-        id: string;
-        y: number;
-    }>, removeIds: string[]) => void, dt?: number): void;
-    controlSpacecraft(spacecraft: Spacecraft, targetX: number, _targetY: number): Spacecraft;
-    controlSpacecraftSV(targetX: number): void;
-    releaseSpacecraftSV(): void;
-    releaseSpacecraft(spacecraft: Spacecraft): Spacecraft;
-    checkCollision(spacecraft: Spacecraft, asteroids: Asteroid[]): {
-        collision: boolean;
-        asteroidId?: string;
-    };
-    private spacecraftAsteroidCollision;
-    checkAsteroidPass(spacecraft: Spacecraft, asteroids: Asteroid[]): string[];
-    createCollisionParticles(x: number, y: number): void;
-    private updateParticles;
-    getParticles(): Particle[];
-    isInCollisionImmunity(): boolean;
-    getRemainingImmunityTime(): number;
-    getInitialSpacecraft(): Spacecraft;
-}
-export declare const createSpaceFighterService: (width: number, height: number) => SpaceFighterGameService;

package/lib/typescript/src/games/space-fighter/SpaceFighterStore.d.ts

@@ -1,54 +0,0 @@
-import type { Asteroid, Spacecraft } from './SpaceFighterService';
-export interface SpaceFighterStore {
-    score: number;
-    timeLeft: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    lives: number;
-    asteroids: Asteroid[];
-    spacecraft: Spacecraft;
-    spacecraftPath: {
-        x: number;
-        y: number;
-    }[];
-    isControllingSpacecraft: boolean;
-    offset: number;
-    listVersion: number;
-    setOffset: (offset: number) => void;
-    startGame: (gameDuration?: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    decrementTime: () => void;
-    addAsteroids: (asteroids: Asteroid[]) => void;
-    removeAsteroid: (asteroidId: string) => void;
-    batchRemoveAsteroids: (removeIds: string[]) => void;
-    updateAsteroid: (asteroidId: string, updates: Partial<Asteroid>) => void;
-    batchUpdateAsteroids: (updates: Array<{
-        id: string;
-        y: number;
-    }>, removeIds: string[]) => void;
-    updateSpacecraft: (spacecraft: Spacecraft) => void;
-    setSpacecraftPath: (path: {
-        x: number;
-        y: number;
-    }[]) => void;
-    setIsControllingSpacecraft: (isControlling: boolean) => void;
-    markAsteroidPassed: (pairId: string) => void;
-    loseLife: () => void;
-}
-export declare const useSpaceFighterStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SpaceFighterStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: SpaceFighterStore, previousSelectedState: SpaceFighterStore) => void): () => void;
-        <U>(selector: (state: SpaceFighterStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useSFScore: () => number;
-export declare const useSFTimeLeft: () => number;
-export declare const useSFLives: () => number;
-export declare const useSFIsPlaying: () => boolean;
-export declare const useSFGameOver: () => boolean;
-export declare const useSFListVersion: () => number;

package/lib/typescript/src/games/space-fighter/components/AsteroidComponent.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-import type { Asteroid } from '../SpaceFighterService';
-import type { createSpaceFighterService } from '../SpaceFighterService';
-interface AsteroidComponentProps {
-    asteroid: Asteroid;
-    gameService: ReturnType<typeof createSpaceFighterService>;
-}
-export declare const AsteroidComponent: React.FC<AsteroidComponentProps>;
-export {};

package/lib/typescript/src/games/space-fighter/components/GameArea.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-import type { createSpaceFighterService } from '../SpaceFighterService';
-interface GameAreaProps {
-    gameService: ReturnType<typeof createSpaceFighterService>;
-    soundEnabledRef: React.RefObject<boolean>;
-    hapticEnabledRef: React.RefObject<boolean>;
-}
-export declare const GameArea: React.FC<GameAreaProps>;
-export {};

package/lib/typescript/src/games/space-fighter/components/GameBackground.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface GameBackgroundProps {
-    children: React.ReactNode;
-}
-export declare const GameBackground: React.FC<GameBackgroundProps>;
-export {};

package/lib/typescript/src/games/space-fighter/components/ScoreBoard.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-interface ScoreBoardProps {
-    offset?: number;
-}
-export declare const ScoreBoard: React.NamedExoticComponent<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/space-fighter/components/Spacecraft3D.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import { type SharedValue } from 'react-native-reanimated';
-import type { Spacecraft } from '../SpaceFighterService';
-interface Spacecraft3DProps {
-    spacecraft: Spacecraft;
-    isControlled: boolean;
-    xSV: SharedValue<number>;
-    ySV: SharedValue<number>;
-}
-export declare const Spacecraft3D: React.FC<Spacecraft3DProps>;
-export {};

package/lib/typescript/src/games/space-fighter/components/SpacecraftPath.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-interface SpacecraftPathProps {
-    path: {
-        x: number;
-        y: number;
-    }[];
-}
-export declare const SpacecraftPath: React.FC<SpacecraftPathProps>;
-export {};