@nayan-ui/games 1.19.0 → 1.20.0

package/lib/typescript/src/games/block-blast/BlockBlastStore.d.ts

@@ -1,70 +0,0 @@
-export interface BlockPiece {
-    id: string;
-    shape: number[][];
-    color: string;
-}
-export interface GameState {
-    score: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-    timeRemaining: number;
-    gameDuration: number;
-}
-export interface ClearingCell {
-    row: number;
-    col: number;
-    color: string;
-}
-export interface BlockBlastStore extends GameState {
-    grid: (string | null)[][];
-    gridSize: number;
-    gridVersion: number;
-    nextPieces: BlockPiece[];
-    piecesVersion: number;
-    selectedPieceId: string | null;
-    previewPosition: {
-        row: number;
-        col: number;
-    } | null;
-    canPlace: boolean;
-    clearingCells: ClearingCell[];
-    initializeGame: (gridSize?: number) => void;
-    startGame: (gridSize?: number, gameDuration?: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    selectPiece: (pieceId: string) => void;
-    deselectPiece: () => void;
-    updatePreviewPosition: (row: number, col: number, canPlace: boolean) => void;
-    clearPreview: () => void;
-    placePiece: (pieceId: string, row: number, col: number) => boolean;
-    generateNextPieces: () => void;
-    addNewPiece: () => void;
-    clearLines: () => {
-        linesCleared: number;
-        cellsToAnimate: ClearingCell[];
-    };
-    clearClearingCells: () => void;
-    checkGameOver: () => boolean;
-    decrementTime: () => void;
-    checkWinCondition: () => void;
-}
-export declare const useBlockBlastStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<BlockBlastStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: BlockBlastStore, previousSelectedState: BlockBlastStore) => void): () => void;
-        <U>(selector: (state: BlockBlastStore) => 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 useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useGameWon: () => boolean;
-export declare const useTimeRemaining: () => number;
-export declare const useGridVersion: () => number;
-export declare const usePiecesVersion: () => number;
-export declare const useSelectedPieceId: () => string | null;
-export declare const useClearingCells: () => ClearingCell[];

package/lib/typescript/src/games/block-blast/components/BlockPieceComponent.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-interface BlockPieceComponentProps {
-    shape: number[][];
-    color: string;
-    cellSize: number;
-    cellGap: number;
-    scale?: number;
-}
-export declare const BlockPieceComponent: React.MemoExoticComponent<({ shape, color, cellSize, cellGap, scale }: BlockPieceComponentProps) => React.JSX.Element>;
-export declare const render3DCell: (x: number, y: number, cellSize: number, color: string, key: string) => React.JSX.Element;
-export {};

package/lib/typescript/src/games/block-blast/components/GameArea.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { BlockBlastService } from '../BlockBlastService';
-interface GameAreaProps {
-    gridSize: number;
-    cellSize: number;
-    cellGap: number;
-    gameService: BlockBlastService;
-    offset: number;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/block-blast/components/GridComponent.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-interface GridComponentProps {
-    gridSize: number;
-    cellSize: number;
-    cellGap: number;
-}
-export declare const GridComponent: React.MemoExoticComponent<({ gridSize, cellSize, cellGap }: GridComponentProps) => React.JSX.Element>;
-export {};

package/lib/typescript/src/games/block-blast/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/block-breaker/BlockBreakerService.d.ts

@@ -1,88 +0,0 @@
-import { PowerUpType } from './BlockBreakerConstants';
-import type { SharedValue } from 'react-native-reanimated';
-interface InternalBall {
-    id: string;
-    x: number;
-    y: number;
-    vx: number;
-    vy: number;
-}
-interface InternalPowerUp {
-    id: string;
-    type: PowerUpType;
-    x: number;
-    y: number;
-}
-export interface BallSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-    vx: SharedValue<number>;
-    vy: SharedValue<number>;
-}
-export interface PowerUpSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-}
-export interface PaddleSharedValues {
-    x: SharedValue<number>;
-    width: SharedValue<number>;
-}
-export declare class BlockBreakerService {
-    private destroyed;
-    private animationRef;
-    private pendingTimeouts;
-    private lastFrameTime;
-    private balls;
-    private powerUps;
-    private paddleX;
-    private paddleWidth;
-    private combo;
-    private cachedIsPlaying;
-    setPlaying(value: boolean): void;
-    private bricksCache;
-    private bricksDirty;
-    private readonly _removeSet;
-    private readonly _hitMap;
-    private ballSharedValues;
-    private powerUpSharedValues;
-    private paddleSV;
-    private onBallListChange;
-    private onPowerUpListChange;
-    private onBrickHit?;
-    private onBrickDestroy?;
-    private onPaddleHit?;
-    private onWallHit?;
-    private onLoseLife?;
-    private onGameOver?;
-    private onGameWon?;
-    private onPowerUp?;
-    private onLaunch?;
-    private onCombo?;
-    constructor();
-    registerBallSharedValues(ballId: string, sv: BallSharedValues): void;
-    unregisterBallSharedValues(ballId: string): void;
-    registerPowerUpSharedValues(puId: string, sv: PowerUpSharedValues): void;
-    unregisterPowerUpSharedValues(puId: string): void;
-    registerPaddleSharedValues(sv: PaddleSharedValues): void;
-    setOnBallListChange(cb: () => void): void;
-    setOnPowerUpListChange(cb: () => void): void;
-    setCallbacks(onBrickHit?: () => void, onBrickDestroy?: () => void, onPaddleHit?: () => void, onWallHit?: () => void, onLoseLife?: () => void, onGameOver?: () => void, onGameWon?: () => void, onPowerUp?: () => void, onLaunch?: () => void, onCombo?: () => void): void;
-    setPaddleX(x: number): void;
-    getBalls(): InternalBall[];
-    getPowerUps(): InternalPowerUp[];
-    getPaddleX(): number;
-    startGame(): void;
-    resetGame(): void;
-    cleanup(): void;
-    private safeTimeout;
-    initializeBricks(): void;
-    private launchBall;
-    private addExtraBall;
-    startPhysicsLoop(): void;
-    stopPhysicsLoop(): void;
-    private syncBricksCache;
-    private update;
-    private updatePowerUps;
-    private applyPowerUp;
-}
-export {};

package/lib/typescript/src/games/block-breaker/BlockBreakerStore.d.ts

@@ -1,47 +0,0 @@
-export interface Brick {
-    id: string;
-    row: number;
-    col: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-    hits: number;
-}
-export interface BlockBreakerState {
-    score: number;
-    lives: number;
-    timeRemaining: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-    bricks: Brick[];
-    brickVersion: number;
-    startGame: (timeLimit: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    updateTimeRemaining: (delta: number) => void;
-    setBricks: (bricks: Brick[]) => void;
-    loseLife: () => void;
-    setGameOver: () => void;
-    setGameWon: () => void;
-}
-export declare const useBlockBreakerStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<BlockBreakerState>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: BlockBreakerState, previousSelectedState: BlockBreakerState) => void): () => void;
-        <U>(selector: (state: BlockBreakerState) => 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 useLives: () => number;
-export declare const useTimeRemaining: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useGameWon: () => boolean;
-export declare const useBricks: () => Brick[];
-export declare const useBrickVersion: () => number;

package/lib/typescript/src/games/block-breaker/components/BlastAnimation.d.ts

@@ -1,15 +0,0 @@
-import React from 'react';
-export interface BlastBrick {
-    id: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    color: string;
-}
-interface BlastAnimationProps {
-    bricks: BlastBrick[];
-    onComplete: () => void;
-}
-export declare const BlastAnimation: React.FC<BlastAnimationProps>;
-export {};

package/lib/typescript/src/games/block-breaker/components/GameArea.d.ts

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

package/lib/typescript/src/games/block-breaker/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/bluk/BlukService.d.ts

@@ -1,71 +0,0 @@
-import type { SharedValue } from 'react-native-reanimated';
-export interface BlockSharedValues {
-    x: SharedValue<number>;
-    y: SharedValue<number>;
-    rotation: SharedValue<number>;
-    opacity: SharedValue<number>;
-}
-export interface CameraSharedValues {
-    x: SharedValue<number>;
-}
-interface Point {
-    x: number;
-    y: number;
-}
-type Phase = 'resting' | 'flying' | 'dead';
-export declare class BlukService {
-    private destroyed;
-    private animationRef;
-    private pendingTimeouts;
-    private lastFrameTime;
-    private pillars;
-    private currentIndex;
-    private landedCount;
-    private pillarSeq;
-    private phase;
-    private bx;
-    private by;
-    private prevBy;
-    private vx;
-    private vy;
-    private cachedIsPlaying;
-    private blockSV;
-    private cameraSV;
-    private onJump?;
-    private onLand?;
-    private onPerfect?;
-    private onFall?;
-    private onGameOver?;
-    setPlaying(value: boolean): void;
-    registerBlockSharedValues(sv: BlockSharedValues): void;
-    registerCameraSharedValues(sv: CameraSharedValues): void;
-    setCallbacks(onJump?: () => void, onLand?: () => void, onPerfect?: () => void, onFall?: () => void, onGameOver?: () => void): void;
-    private safeTimeout;
-    private makePillar;
-    private randWidth;
-    private nextGap;
-    private maxVisibleGap;
-    private appendPillar;
-    private ensurePillarsAhead;
-    private prunePillars;
-    private syncPillars;
-    initialize(): void;
-    startGame(): void;
-    getLaunchVelocity(dragDx: number, dragDy: number): {
-        vx: number;
-        vy: number;
-    } | null;
-    private findLanding;
-    computeTrajectory(vx: number, vy: number): Point[];
-    launch(vx: number, vy: number): void;
-    startPhysicsLoop(): void;
-    stopPhysicsLoop(): void;
-    private update;
-    private handleLand;
-    private handleFall;
-    getPhase(): Phase;
-    isDirty(): boolean;
-    resetGame(): void;
-    cleanup(): void;
-}
-export {};

package/lib/typescript/src/games/bluk/BlukStore.d.ts

@@ -1,52 +0,0 @@
-export declare const GAME_DURATION = 120;
-export interface Pillar {
-    id: string;
-    worldX: number;
-    topY: number;
-    width: number;
-    colorIndex: number;
-}
-export interface BlukState {
-    score: number;
-    best: number;
-    combo: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-    timeRemaining: number;
-    pillars: Pillar[];
-    pillarsVersion: number;
-    showPerfect: boolean;
-    blockColorIndex: number;
-}
-export interface BlukStore extends BlukState {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    setGameOver: () => void;
-    setGameWon: () => void;
-    setTimeRemaining: (time: number) => void;
-    setPillars: (pillars: Pillar[]) => void;
-    setShowPerfect: (show: boolean) => void;
-    landPerfect: (points: number, combo: number, colorIndex: number) => void;
-    landNormal: (points: number, colorIndex: number) => void;
-}
-export declare const useBlukStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<BlukStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: BlukStore, previousSelectedState: BlukStore) => void): () => void;
-        <U>(selector: (state: BlukStore) => 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 useBest: () => number;
-export declare const useCombo: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useGameOver: () => boolean;
-export declare const useGameWon: () => boolean;
-export declare const useTimeRemaining: () => number;
-export declare const usePillarsVersion: () => number;
-export declare const useShowPerfect: () => boolean;
-export declare const useBlockColorIndex: () => number;

package/lib/typescript/src/games/bluk/components/GameArea.d.ts

@@ -1,17 +0,0 @@
-import React from 'react';
-import { type SharedValue } from 'react-native-reanimated';
-import type { BlukService } from '../BlukService';
-interface GameAreaProps {
-    gameService: BlukService;
-    offset?: number;
-    cameraX: SharedValue<number>;
-}
-export interface AimHandle {
-    update: (points: {
-        x: number;
-        y: number;
-    }[]) => void;
-    clear: () => void;
-}
-export declare const GameArea: React.NamedExoticComponent<GameAreaProps>;
-export {};

package/lib/typescript/src/games/bluk/components/GameBackground.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-import { type SharedValue } from 'react-native-reanimated';
-interface GameBackgroundProps {
-    children: React.ReactNode;
-    offset?: number;
-    cameraX?: SharedValue<number>;
-}
-export declare const GameBackground: React.NamedExoticComponent<GameBackgroundProps>;
-export {};

package/lib/typescript/src/games/bluk/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/bubble-shooter/BubbleShooterService.d.ts

@@ -1,35 +0,0 @@
-import { type Bubble } from './BubbleShooterStore';
-export declare class BubbleShooterService {
-    private rowCount;
-    private colorCount;
-    private shooterX;
-    private shooterY;
-    private shooterAngle;
-    cachedIsPlaying: boolean;
-    private shootingActive;
-    private shootingX;
-    private shootingY;
-    private shootingVx;
-    private shootingVy;
-    private shootingColorLocal;
-    private onShoot?;
-    private onBubbleMatch?;
-    private onGameWon?;
-    constructor();
-    setPlaying(playing: boolean): void;
-    setCallbacks(onShoot?: () => void, onBubbleMatch?: () => void, onGameWon?: () => void): void;
-    setDifficulty(rowCount: number, colorCount: number): void;
-    setShooterPosition(x: number, y: number): void;
-    setShooterAngle(angle: number): void;
-    startGame(): void;
-    stopGame(): void;
-    resetGame(): void;
-    cleanup(): void;
-    initializeBubbles(): void;
-    updateShootingBubble(): void;
-    checkBubbleCollision(x: number, y: number): Bubble | null;
-    snapBubbleToGrid(x: number, y: number, color: string): void;
-    private addBubbleAndCheckMatches;
-    findConnectedBubbles(startBubble: Bubble, allBubbles: Bubble[]): Bubble[];
-    shoot(): void;
-}

package/lib/typescript/src/games/bubble-shooter/BubbleShooterStore.d.ts

@@ -1,63 +0,0 @@
-export interface Bubble {
-    id: string;
-    row: number;
-    col: number;
-    color: string;
-    x: number;
-    y: number;
-}
-export interface ShootingBubble {
-    id: string;
-    x: number;
-    y: number;
-    vx: number;
-    vy: number;
-    color: string;
-}
-export interface GameState {
-    score: number;
-    timeRemaining: number;
-    isPlaying: boolean;
-    gameOver: boolean;
-    gameWon: boolean;
-}
-export interface BubbleShooterStore extends GameState {
-    shooterAngle: number;
-    bubbles: Bubble[];
-    bubbleVersion: number;
-    shootingBubble: ShootingBubble | null;
-    nextBubbleColor: string;
-    currentBubbleColor: string;
-    startGame: (rowCount: number, colorCount: number, timeLimit: number) => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    updateScore: (points: number) => void;
-    updateTimeRemaining: (time: number) => void;
-    setTimeRemaining: (time: number) => void;
-    setShooterAngle: (angle: number) => void;
-    shootBubble: () => void;
-    updateShootingBubble: (bubble: ShootingBubble) => void;
-    clearShootingBubble: () => void;
-    addBubble: (bubble: Bubble) => void;
-    removeBubbles: (bubbleIds: string[]) => void;
-    updateBubbles: (bubbles: Bubble[]) => void;
-    setGameOver: () => void;
-    setGameWon: () => void;
-    generateNextBubble: () => void;
-}
-export declare const useBubbleShooterStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<BubbleShooterStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: BubbleShooterStore, previousSelectedState: BubbleShooterStore) => void): () => void;
-        <U>(selector: (state: BubbleShooterStore) => 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 useBubbleVersion: () => number;
-export declare const useBubblesRemaining: () => number;

package/lib/typescript/src/games/bubble-shooter/components/GameArea.d.ts

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

package/lib/typescript/src/games/bubble-shooter/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/candy-crush/CandyCrushService.d.ts

@@ -1,37 +0,0 @@
-import { CANDY_TYPES } from './CandyCrushConstants';
-export type CandyType = (typeof CANDY_TYPES)[keyof typeof CANDY_TYPES];
-export interface Candy {
-    id: number;
-    row: number;
-    col: number;
-    type: number;
-    specialType: CandyType;
-    isMatched: boolean;
-    isFalling: boolean;
-    fromRow: number;
-}
-export type CandyGrid = (Candy | null)[][];
-export interface MatchResult {
-    matches: Candy[];
-    score: number;
-    hasMatches: boolean;
-}
-export interface SwapResult {
-    isValid: boolean;
-    matches: Candy[];
-}
-export declare class CandyCrushService {
-    private nextCandyId;
-    createGrid(): CandyGrid;
-    initializeGrid(candyTypes: number): CandyGrid;
-    private wouldCreateMatch;
-    canSwap(candy1: Candy, candy2: Candy): boolean;
-    swapCandies(grid: CandyGrid, candy1: Candy, candy2: Candy): void;
-    findMatches(grid: CandyGrid): MatchResult;
-    removeMatches(grid: CandyGrid, matches: Candy[]): void;
-    applyGravity(grid: CandyGrid): boolean;
-    fillEmptySpaces(grid: CandyGrid, candyTypes: number): Candy[];
-    hasPossibleMoves(grid: CandyGrid): boolean;
-    getCandyColor(type: number): string;
-    resetIdCounter(): void;
-}

package/lib/typescript/src/games/candy-crush/CandyCrushStore.d.ts

@@ -1,53 +0,0 @@
-import type { CandyGrid, Candy } from './CandyCrushService';
-export interface ClearingCell {
-    row: number;
-    col: number;
-    color: string;
-}
-export interface CandyCrushState {
-    grid: CandyGrid;
-    gridVersion: number;
-    score: number;
-    timeRemaining: number;
-    gameDuration: number;
-    isPlaying: boolean;
-    isGameOver: boolean;
-    selectedCandyId: number;
-    isProcessing: boolean;
-    candyTypes: number;
-    enableSounds: boolean;
-    enableHaptics: boolean;
-    comboCount: number;
-    matchedCandyIds: Set<number>;
-    fallingCandyIds: Set<number>;
-    clearingCells: ClearingCell[];
-}
-export interface CandyCrushStore extends CandyCrushState {
-    startGame: () => void;
-    stopGame: () => void;
-    resetGame: () => void;
-    initializeGame: () => void;
-    selectCandy: (candy: Candy) => void;
-    swapByDirection: (row: number, col: number, direction: 'up' | 'down' | 'left' | 'right') => void;
-    processMatches: () => Promise<void>;
-    updateSettings: (enableSounds: boolean, enableHaptics: boolean) => void;
-    clearClearingCells: () => void;
-}
-export declare const useCandyCrushStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<CandyCrushStore>, "subscribe"> & {
-    subscribe: {
-        (listener: (selectedState: CandyCrushStore, previousSelectedState: CandyCrushStore) => void): () => void;
-        <U>(selector: (state: CandyCrushStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
-            equalityFn?: ((a: U, b: U) => boolean) | undefined;
-            fireImmediately?: boolean;
-        } | undefined): () => void;
-    };
-}>;
-export declare const useGridVersion: () => number;
-export declare const useScore: () => number;
-export declare const useTimeRemaining: () => number;
-export declare const useGameDuration: () => number;
-export declare const useIsPlaying: () => boolean;
-export declare const useIsGameOver: () => boolean;
-export declare const useSelectedCandyId: () => number;
-export declare const useComboCount: () => number;
-export declare const useClearingCells: () => ClearingCell[];

package/lib/typescript/src/games/candy-crush/components/CandyItem.d.ts

@@ -1,11 +0,0 @@
-import React from 'react';
-import type { Candy } from '../CandyCrushService';
-interface CandyItemProps {
-    candy: Candy;
-    isSelected: boolean;
-    isMatched: boolean;
-    isFalling: boolean;
-    onSwipe: (row: number, col: number, direction: 'up' | 'down' | 'left' | 'right') => void;
-}
-export declare const CandyItem: React.NamedExoticComponent<CandyItemProps>;
-export {};

package/lib/typescript/src/games/candy-crush/components/GameGrid.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const GameGrid: React.NamedExoticComponent<{}>;

package/lib/typescript/src/games/candy-crush/components/ScoreBoard.d.ts

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