@nayan-ui/games 1.19.0 → 1.21.0

package/lib/typescript/src/games/ludo-king/LudoKingStore.d.ts

@@ -1,34 +0,0 @@
-import type { GameSettings } from '../../services/UtilsService';
-import { type Token, type Player, type GamePhase } from './LudoKingService';
-export interface LudoKingState {
-    isPlaying: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    players: Player[];
-    currentPlayerIndex: number;
-    diceValue: number | null;
-    isRolling: boolean;
-    gamePhase: GamePhase;
-    selectedToken: Token | null;
-    movableTokens: Token[];
-    playerScore: number;
-    consecutiveSixes: number;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    initializeGame: () => void;
-    rollDiceAction: (settings: GameSettings) => void;
-    selectToken: (token: Token, settings: GameSettings) => void;
-    makeAITurn: (settings: GameSettings) => void;
-}
-export declare const useLudoKingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<LudoKingState>>;
-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 useMovableTokens: () => Token[];
-export declare const usePlayerScore: () => number;

package/lib/typescript/src/games/ludo-king/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/ludo-king/components/GameBoard.d.ts

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

package/lib/typescript/src/games/ludo-king/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/maze-runner/MazeRunnerStore.d.ts

@@ -1,62 +0,0 @@
-import type { GameSettings } from '../../services/UtilsService';
-export interface Position {
-    x: number;
-    y: number;
-}
-export interface MazeCell {
-    x: number;
-    y: number;
-    walls: {
-        top: boolean;
-        right: boolean;
-        bottom: boolean;
-        left: boolean;
-    };
-    visited: boolean;
-}
-export interface Wall {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    type: 'horizontal' | 'vertical';
-}
-export interface MazeRunnerState {
-    isPlaying: boolean;
-    isPaused: boolean;
-    isGameOver: boolean;
-    isWin: boolean;
-    score: number;
-    timeElapsed: number;
-    ballPosition: Position;
-    targetPosition: Position;
-    maze: MazeCell[][];
-    walls: Wall[];
-    gridSize: number;
-    cellSize: number;
-    gameAreaWidth: number;
-    gameAreaHeight: number;
-    gameDuration: number;
-    initializeGame: (settings: GameSettings, gameAreaWidth: number, gameAreaHeight: number) => void;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    pauseGame: () => void;
-    resumeGame: () => void;
-    updateBallPosition: (position: Position) => boolean;
-    incrementTime: () => void;
-    generateNewMaze: () => void;
-}
-export declare const useMazeRunnerStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MazeRunnerState>>;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsPaused: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useIsWin: () => boolean;
-export declare const useScore: () => number;
-export declare const useTimeElapsed: () => number;
-export declare const useBallPosition: () => Position;
-export declare const useTargetPosition: () => Position;
-export declare const useWalls: () => Wall[];
-export declare const useGridSize: () => number;
-export declare const useCellSize: () => number;
-export declare const useGameDuration: () => number;

package/lib/typescript/src/games/maze-runner/components/EnhancedBallComponent.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { Position } from '../MazeRunnerStore';
-interface EnhancedBallComponentProps {
-    position: Position;
-    size: number;
-    isDragging: boolean;
-    isCompleted: boolean;
-}
-export declare const EnhancedBallComponent: React.NamedExoticComponent<EnhancedBallComponentProps>;
-export {};

package/lib/typescript/src/games/maze-runner/components/EnhancedGameArea.d.ts

@@ -1,33 +0,0 @@
-import React from 'react';
-import type { Position, Wall } from '../MazeRunnerStore';
-interface GameState {
-    isPlaying: boolean;
-    isPaused: boolean;
-    score: number;
-    timeElapsed: number;
-    ballPosition: Position;
-    targetPosition: Position;
-    isCompleted: boolean;
-    gameOver: boolean;
-}
-interface GameConfig {
-    GRID_SIZE: number;
-    CELL_SIZE: number;
-    BALL_SIZE: number;
-    PIPE_WIDTH: number;
-    GAME_AREA_WIDTH: number;
-    GAME_AREA_HEIGHT: number;
-    COLLISION_TOLERANCE: number;
-    SCORE_PER_COMPLETION: number;
-    TIME_BONUS_MULTIPLIER: number;
-    GAME_DURATION: number;
-}
-interface EnhancedGameAreaProps {
-    gameState: GameState;
-    gameConfig: GameConfig;
-    walls: Wall[];
-    onBallPositionChange: (position: Position) => boolean;
-    hapticEnabled: boolean;
-}
-export declare const EnhancedGameArea: React.NamedExoticComponent<EnhancedGameAreaProps>;
-export {};

package/lib/typescript/src/games/maze-runner/components/ScoreBoard.d.ts

@@ -1,24 +0,0 @@
-import React from 'react';
-interface GameState {
-    isPlaying: boolean;
-    isPaused: boolean;
-    score: number;
-    timeElapsed: number;
-    ballPosition: {
-        x: number;
-        y: number;
-    };
-    targetPosition: {
-        x: number;
-        y: number;
-    };
-    isCompleted: boolean;
-    gameOver: boolean;
-}
-interface ScoreBoardProps {
-    offset?: number;
-    gameState: GameState;
-    gameDuration: number;
-}
-export declare const ScoreBoard: React.FC<ScoreBoardProps>;
-export {};

package/lib/typescript/src/games/maze-runner/components/SkiaPipeComponent.d.ts

@@ -1,24 +0,0 @@
-import React from 'react';
-type PipeSegment = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    start: {
-        x: number;
-        y: number;
-    };
-    end: {
-        x: number;
-        y: number;
-    };
-    direction: 'horizontal' | 'vertical';
-    type: 'straight' | 'corner';
-    cornerType?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
-};
-interface SkiaPipeComponentProps {
-    segment: PipeSegment;
-    pipeWidth: number;
-}
-export declare const SkiaPipeComponent: React.FC<SkiaPipeComponentProps>;
-export {};

package/lib/typescript/src/games/maze-runner/components/WallComponent.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-import type { Wall } from '../MazeRunnerStore';
-interface WallComponentProps {
-    walls: Wall[];
-    width: number;
-    height: number;
-}
-export declare const WallComponent: React.NamedExoticComponent<WallComponentProps>;
-export {};

package/lib/typescript/src/games/memory-match/MemoryMatchService.d.ts

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

package/lib/typescript/src/games/memory-match/MemoryMatchStore.d.ts

@@ -1,42 +0,0 @@
-import { type GameSettings } from '../../services/UtilsService';
-import { type Card } from './MemoryMatchConstants';
-export interface MemoryMatchState {
-    isPlaying: boolean;
-    isWon: boolean;
-    isGameOver: boolean;
-    cards: Card[];
-    boardVersion: number;
-    resetVersion: number;
-    firstIndex: number;
-    lock: boolean;
-    totalPairs: number;
-    matchedPairs: number;
-    moves: number;
-    score: number;
-    timeLeft: number;
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    flipCard: (index: number, settings: GameSettings) => void;
-    decrementTime: () => void;
-}
-export declare const useMemoryMatchStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<MemoryMatchState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: MemoryMatchState, previousSelectedState: MemoryMatchState) => void): () => void;
-        <U>(selector: (state: MemoryMatchState) => 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 useIsWon: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useBoardVersion: () => number;
-export declare const useResetVersion: () => number;
-export declare const useScore: () => number;
-export declare const useTimeLeft: () => number;
-export declare const useMatchedPairs: () => number;
-export declare const useTotalPairs: () => number;
-export declare const useCardState: (index: number) => import("./MemoryMatchConstants").CardState;
-export declare const useCardSymbol: (index: number) => number;

package/lib/typescript/src/games/memory-match/components/Card.d.ts

@@ -1,6 +0,0 @@
-import React from 'react';
-import { type CardRect } from '../MemoryMatchConstants';
-export declare const CardNode: React.MemoExoticComponent<({ index, rect }: {
-    index: number;
-    rect: CardRect;
-}) => React.JSX.Element>;

package/lib/typescript/src/games/memory-match/components/GameBoard.d.ts

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

package/lib/typescript/src/games/memory-match/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/mine-sweeper/MineSweeperService.d.ts

@@ -1,22 +0,0 @@
-export declare class MineSweeperService {
-    private destroyed;
-    private firstClick;
-    private onReveal?;
-    private onFlag?;
-    private onMineHit?;
-    private onGameOver?;
-    private onGameWon?;
-    constructor();
-    setCallbacks(onReveal?: () => void, onFlag?: () => void, onMineHit?: () => void, onGameOver?: () => void, onGameWon?: () => void): void;
-    initializeGrid(): void;
-    private placeMines;
-    startGame(): void;
-    handleCellTap(row: number, col: number): void;
-    handleCellLongPress(row: number, col: number): void;
-    private toggleFlag;
-    private floodReveal;
-    private revealAllMines;
-    private checkWin;
-    resetGame(): void;
-    cleanup(): void;
-}

package/lib/typescript/src/games/mine-sweeper/MineSweeperStore.d.ts

@@ -1,73 +0,0 @@
-export declare enum CellState {
-    HIDDEN = "hidden",
-    REVEALED = "revealed",
-    FLAGGED = "flagged"
-}
-export interface Cell {
-    row: number;
-    col: number;
-    isMine: boolean;
-    state: CellState;
-    adjacentMines: number;
-}
-export interface MineSweeperState {
-    score: number;
-    timeRemaining: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-    grid: Cell[][];
-    minesRemaining: number;
-    revealedCount: number;
-    totalSafeCells: number;
-    flagMode: boolean;
-    gridVersion: number;
-}
-export interface MineSweeperStore extends MineSweeperState {
-    startGame: (timeLimit: number) => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    updateTimeRemaining: (delta: number) => void;
-    setGameOver: () => void;
-    setGameWon: () => void;
-    setGrid: (grid: Cell[][]) => void;
-    updateCell: (row: number, col: number, state: CellState) => void;
-    batchRevealCells: (cells: Array<{
-        row: number;
-        col: number;
-    }>) => void;
-    setMinesRemaining: (count: number) => void;
-    incrementRevealedCount: (count: number) => void;
-    setTotalSafeCells: (count: number) => void;
-    toggleFlagMode: () => void;
-    incrementGridVersion: () => void;
-    batchRevealAndScore: (cells: Array<{
-        row: number;
-        col: number;
-    }>, points: number) => void;
-    batchToggleFlag: (row: number, col: number, newState: CellState, minesDelta: number, points: number) => void;
-    batchRevealMines: (cells: Array<{
-        row: number;
-        col: number;
-    }>) => void;
-}
-export declare const useMineSweeperStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<MineSweeperStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: MineSweeperStore, previousSelectedState: MineSweeperStore) => void): () => void;
-        <U>(selector: (state: MineSweeperStore) => 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 useTimeRemaining: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useGameWon: () => boolean;
-export declare const useGrid: () => Cell[][];
-export declare const useMinesRemaining: () => number;
-export declare const useFlagMode: () => boolean;
-export declare const useGridVersion: () => number;
-export declare const useCellSig: (row: number, col: number) => string;
-export declare const useGridReady: () => boolean;

package/lib/typescript/src/games/mine-sweeper/components/GameArea.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { MineSweeperService } from '../MineSweeperService';
-interface GameAreaProps {
-    gameService: MineSweeperService;
-    offset?: number;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/mine-sweeper/components/ScoreBoard.d.ts

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

package/lib/typescript/src/games/mob-control/MobControlService.d.ts

@@ -1,74 +0,0 @@
-import type { SharedValue } from 'react-native-reanimated';
-export interface BlobSV {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-}
-export interface GateSV {
-    y: SharedValue<number>;
-}
-export declare class MobControlService {
-    private destroyed;
-    private animationRef;
-    private lastFrameTime;
-    private blobs;
-    private gates;
-    private seq;
-    private cannonX;
-    private cannonXSV;
-    private blobSV;
-    private gateSV;
-    private fireAccum;
-    private gateAccum;
-    private enemyAccum;
-    private timeRemainingMs;
-    private lastReportedSec;
-    private level;
-    private cachedIsPlaying;
-    private entitiesDirty;
-    private cachedEnemyHp;
-    private cachedPlayerHp;
-    private cachedScore;
-    private onShoot?;
-    private onGate?;
-    private onHit?;
-    private onClash?;
-    private onLevelUp?;
-    private onDamage?;
-    private onGameOver?;
-    private onBlast?;
-    setPlaying(v: boolean): void;
-    setCannonX(x: number): void;
-    registerCannonSV(sv: SharedValue<number>): void;
-    registerBlobSV(id: string, sv: BlobSV): void;
-    unregisterBlobSV(id: string): void;
-    registerGateSV(id: string, sv: GateSV): void;
-    unregisterGateSV(id: string): void;
-    setCallbacks(cbs: {
-        onShoot?: () => void;
-        onGate?: () => void;
-        onHit?: () => void;
-        onClash?: () => void;
-        onLevelUp?: () => void;
-        onDamage?: () => void;
-        onGameOver?: () => void;
-    }): void;
-    setBlastCallback(fn: (x: number, y: number, color: string) => void): void;
-    private roadHalfAt;
-    private laneX;
-    private spawnPlayerBlob;
-    private spawnEnemyBlob;
-    private spawnGate;
-    private applyGate;
-    initialize(): void;
-    startGame(): void;
-    private startLoop;
-    stopLoop(): void;
-    private syncEntities;
-    private update;
-    private removeBlob;
-    private pushFrameState;
-    private levelUp;
-    private handleGameOver;
-    resetGame(): void;
-    cleanup(): void;
-}

package/lib/typescript/src/games/mob-control/MobControlStore.d.ts

@@ -1,66 +0,0 @@
-import { type GateOp } from './MobControlConstants';
-export interface BlobEntity {
-    id: string;
-    team: 'player' | 'enemy';
-    count: number;
-}
-export interface GateEntity {
-    id: string;
-    op: GateOp;
-    u: number;
-    wFrac: number;
-}
-export interface MobControlState {
-    score: number;
-    best: number;
-    level: number;
-    enemyHp: number;
-    enemyMaxHp: number;
-    playerHp: number;
-    playerMaxHp: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    won: boolean;
-    timeLeft: number;
-    blobs: BlobEntity[];
-    gates: GateEntity[];
-    entitiesVersion: number;
-}
-export interface MobControlStore extends MobControlState {
-    startGame: (enemyHp: number, playerHp: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    addScore: (points: number) => void;
-    setTimeLeft: (seconds: number) => void;
-    setGameOver: (won?: boolean) => void;
-    setEntities: (blobs: BlobEntity[], gates: GateEntity[]) => void;
-    levelUpBatch: (level: number, enemyHp: number, scorePoints: number) => void;
-    batchFrameOutcome: (delta: {
-        scoreAdd?: number;
-        enemyHp?: number;
-        playerHp?: number;
-        blobs?: BlobEntity[];
-        gates?: GateEntity[];
-    }) => void;
-}
-export declare const useMobControlStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<MobControlStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: MobControlStore, previousSelectedState: MobControlStore) => void): () => void;
-        <U>(selector: (state: MobControlStore) => 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 useWon: () => boolean;
-export declare const useBest: () => number;
-export declare const useLevel: () => number;
-export declare const useEnemyHp: () => number;
-export declare const useEnemyMaxHp: () => number;
-export declare const usePlayerHp: () => number;
-export declare const usePlayerMaxHp: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useEntitiesVersion: () => number;

package/lib/typescript/src/games/mob-control/components/GameArea.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { MobControlService } from '../MobControlService';
-interface GameAreaProps {
-    gameService: MobControlService;
-    offset?: number;
-}
-export interface BlastHandle {
-    add: (x: number, y: number, color: string) => void;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/mob-control/components/ScoreBoard.d.ts

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

package/lib/typescript/src/games/number-search/NumberSearchConstants.d.ts

@@ -1,63 +0,0 @@
-export declare const NUMBER_SEARCH_COLORS: {
-    BACKGROUND: string;
-    PRIMARY: string;
-    CELL_FACE: string;
-    CELL_TOP_HIGHLIGHT: string;
-    CELL_BOTTOM_SHADOW: string;
-    CELL_EDGE_SHADOW: string;
-    CELL_BEVEL_HIGHLIGHT: string;
-    CELL_BEVEL_LEFT: string;
-    CELL_TEXT: string;
-    BOARD_BG: string;
-    SELECTION_COLOR: string;
-    FOUND_NUMBER_COLOR: string;
-    NUMBER_LIST_FOUND: string;
-    NUMBER_LIST_UNFOUND: string;
-    NUMBER_PILL_BG: string;
-    NUMBER_PILL_BORDER: string;
-    NUMBER_PILL_FOUND_BG: string;
-    NUMBER_PILL_FOUND_BORDER: string;
-};
-export declare const NUMBER_SEARCH_GAME_CONFIG: {
-    GRID_SIZE: number;
-    NUMBERS_COUNT: number;
-    CELL_SIZE: number;
-    CELL_MARGIN: number;
-    BOARD_PADDING: number;
-    ANIMATION_DURATION: number;
-    TIME_LIMIT: number;
-};
-export declare const NUMBER_LISTS: string[];
-export declare const DIRECTIONS: readonly [{
-    readonly dx: 1;
-    readonly dy: 0;
-    readonly name: "right";
-}, {
-    readonly dx: 0;
-    readonly dy: 1;
-    readonly name: "down";
-}, {
-    readonly dx: 1;
-    readonly dy: 1;
-    readonly name: "diagonal-down-right";
-}, {
-    readonly dx: -1;
-    readonly dy: 1;
-    readonly name: "diagonal-down-left";
-}, {
-    readonly dx: -1;
-    readonly dy: 0;
-    readonly name: "left";
-}, {
-    readonly dx: 0;
-    readonly dy: -1;
-    readonly name: "up";
-}, {
-    readonly dx: -1;
-    readonly dy: -1;
-    readonly name: "diagonal-up-left";
-}, {
-    readonly dx: 1;
-    readonly dy: -1;
-    readonly name: "diagonal-up-right";
-}];

package/lib/typescript/src/games/number-search/NumberSearchService.d.ts

@@ -1,34 +0,0 @@
-export interface PlacedNumber {
-    number: string;
-    startRow: number;
-    startCol: number;
-    direction: {
-        dx: number;
-        dy: number;
-        name: string;
-    };
-    cells: {
-        row: number;
-        col: number;
-    }[];
-}
-export interface GridCell {
-    digit: string;
-    row: number;
-    col: number;
-    isPartOfNumber: boolean;
-    foundNumberIds: string[];
-}
-export declare const formatScore: (score: number) => string;
-export declare const generateNumberSearchGrid: () => {
-    grid: GridCell[][];
-    placedNumbers: PlacedNumber[];
-};
-export declare const getCellsInLine: (startRow: number, startCol: number, endRow: number, endCol: number) => {
-    row: number;
-    col: number;
-}[];
-export declare const checkNumberMatch: (cells: {
-    row: number;
-    col: number;
-}[], grid: GridCell[][], placedNumbers: PlacedNumber[], foundNumbers: string[]) => PlacedNumber | null;