maze-blockly-wrapper 0.7.14 → 0.7.17

package/dist/components/drawing/DrawingGame.d.ts

@@ -1,15 +1,58 @@
-import React from 'react';
-import type { DrawingConfig, GraphicsConfig, RunResult } from './types';
+import React, { Component } from 'react';
+import { type WithTranslation } from 'react-i18next';
+import type { DrawingConfig, DrawingState, GraphicsConfig, RunResult } from './types';
 interface DrawingGameProps {
     className?: string;
     isEditable?: boolean;
     configuration?: DrawingConfig;
     onChange?: (config: DrawingConfig) => void;
     onRunFinish?: (result: RunResult) => void;
+    onReady?: (methods: {
+        getCurrentRunResult: () => RunResult;
+    }) => void;
     maxCommands?: number;
     showControls?: boolean;
     graphicsConfig?: Partial<GraphicsConfig>;
     initialXml?: string;
 }
-declare const DrawingGameWithTranslation: React.ComponentType<DrawingGameProps>;
+interface DrawingGameState {
+    gameState: DrawingState;
+    currentDirection: 'north' | 'south' | 'east' | 'west';
+    isExecuting: boolean;
+    currentCommandIndex: number;
+    generatedCode: string;
+    isGenerating: boolean;
+    executionStartTime?: number;
+}
+declare class DrawingGame extends Component<DrawingGameProps & WithTranslation, DrawingGameState> {
+    constructor(props: DrawingGameProps & WithTranslation);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: DrawingGameProps & WithTranslation): void;
+    componentWillUnmount(): void;
+    private drawingConfig;
+    private graphicsConfig;
+    private getBlocklyConfig;
+    private getDefaultShape;
+    private executionInterval;
+    private blocklyRef;
+    private generateDrawing;
+    private handleCodeChange;
+    private handleConfigChange;
+    private handleExecuteCode;
+    private executeCommands;
+    private executeCommand;
+    private movePenForward;
+    private turnPen;
+    private setPenState;
+    private setPenColor;
+    private calculateAccuracy;
+    private distanceBetweenSegments;
+    private pointToSegmentDistance;
+    private stopExecution;
+    private resetGame;
+    private runCode;
+    getCurrentRunResult: () => RunResult;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+declare const DrawingGameWithTranslation: React.ComponentType<DrawingGameProps & React.RefAttributes<DrawingGame>>;
 export default DrawingGameWithTranslation;

package/dist/components/film/FilmGame.d.ts

@@ -1,15 +1,59 @@
-import React from 'react';
-import type { FilmConfig, GraphicsConfig, RunResult } from './types';
+import React, { Component } from 'react';
+import { type WithTranslation } from 'react-i18next';
+import type { FilmConfig, FilmState, GraphicsConfig, RunResult } from './types';
 interface FilmGameProps {
     className?: string;
     isEditable?: boolean;
     configuration?: FilmConfig;
     onChange?: (config: FilmConfig) => void;
     onRunFinish?: (result: RunResult) => void;
+    onReady?: (methods: {
+        getCurrentRunResult: () => RunResult;
+    }) => void;
     maxCommands?: number;
     showControls?: boolean;
     graphicsConfig?: Partial<GraphicsConfig>;
     initialXml?: string;
 }
-declare const FilmGameWithTranslation: React.ComponentType<FilmGameProps>;
+interface FilmGameState {
+    gameState: FilmState;
+    isExecuting: boolean;
+    currentCommandIndex: number;
+    generatedCode: string;
+    executionStartTime?: number;
+}
+declare class FilmGame extends Component<FilmGameProps & WithTranslation, FilmGameState> {
+    constructor(props: FilmGameProps & WithTranslation);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: FilmGameProps & WithTranslation): void;
+    componentWillUnmount(): void;
+    private filmConfig;
+    private graphicsConfig;
+    private executionInterval;
+    private animationInterval;
+    private blocklyRef;
+    private editorBlocklyRef;
+    private allCommands;
+    private tickCommands;
+    private editorState;
+    private getBlocklyConfig;
+    private handleCodeChange;
+    private handleConfigChange;
+    private handleEditorStateChange;
+    private handleGameTickChange;
+    private handleExecuteCode;
+    private executeCommands;
+    private executeCommand;
+    private evaluateExpression;
+    private playAnimation;
+    private pauseAnimation;
+    private stopAnimation;
+    private compareShapes;
+    private finishGame;
+    private resetGame;
+    private runCode;
+    getCurrentRunResult: () => RunResult;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+declare const FilmGameWithTranslation: React.ComponentType<FilmGameProps & React.RefAttributes<FilmGame>>;
 export default FilmGameWithTranslation;

package/dist/components/maze/MazeGame.d.ts

@@ -7,6 +7,9 @@ interface MazeGameProps {
     configuration?: MazeConfig;
     onChange?: (config: MazeConfig) => void;
     onRunFinish?: (result: RunResult) => void;
+    onReady?: (methods: {
+        getCurrentRunResult: () => RunResult;
+    }) => void;
     maxMoves?: number;
     showControls?: boolean;
     graphicsConfig?: Partial<GraphicsConfig>;
@@ -57,6 +60,6 @@ declare class MazeGame extends Component<MazeGameProps & WithTranslation, MazeGa
     getCurrentRunResult: () => RunResult;
     render(): import("react/jsx-runtime").JSX.Element;
 }
-declare const MazeGameWithTranslation: React.ComponentType<MazeGameProps>;
+declare const MazeGameWithTranslation: React.ComponentType<MazeGameProps & React.RefAttributes<MazeGame>>;
 export { MazeGame as MazeGameBase };
 export default MazeGameWithTranslation;

package/dist/components/music/MusicGame.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
+import React, { Component } from 'react';
 import { type WithTranslation } from 'react-i18next';
-import { type GraphicsConfig, type MusicConfig, type RunResult } from './types';
+import { type GraphicsConfig, type InstrumentType, type MusicBlocklyConfig, type MusicConfig, type MusicState, type Note, type Pause, type RunResult } from './types';
 interface MusicGameProps extends WithTranslation {
     className?: string;
     isEditable?: boolean;
@@ -8,9 +8,93 @@ interface MusicGameProps extends WithTranslation {
     configuration?: MusicConfig;
     onChange?: (config: MusicConfig) => void;
     onRunFinish?: (result: RunResult) => void;
+    onReady?: (methods: {
+        getCurrentRunResult: () => RunResult;
+    }) => void;
     maxCommands?: number;
     showControls?: boolean;
     graphicsConfig?: Partial<GraphicsConfig>;
 }
-declare const MusicGameWithTranslation: React.ComponentType<Omit<MusicGameProps, keyof WithTranslation>>;
+interface MusicGameState {
+    gameState: MusicState;
+    isExecuting: boolean;
+    currentBeat: number;
+    generatedCode: string;
+    executionStartTime?: number;
+    editorNotes: (Note | Pause)[];
+}
+declare class MusicGame extends Component<MusicGameProps, MusicGameState> {
+    private musicConfig;
+    private graphicsConfig;
+    private audioEngine;
+    private playbackInterval;
+    private currentNoteTimeout;
+    private blocklyRef;
+    private editorBlocklyRef;
+    private editorState;
+    constructor(props: MusicGameProps & WithTranslation);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: MusicGameProps & WithTranslation): void;
+    componentWillUnmount(): void;
+    /**
+     * Get Blockly configuration
+     */
+    getBlocklyConfig: () => MusicBlocklyConfig;
+    /**
+     * Handle workspace change
+     */
+    handleWorkspaceChange: (code: string) => void;
+    /**
+     * Parse code and update state without resetting playback if possible
+     */
+    parseCodeAndSetState: (callback?: () => void) => void;
+    /**
+     * Parse and execute the generated code
+     */
+    executeCode: (callback?: () => void) => void;
+    /**
+     * Play the music
+     */
+    playMusic: () => Promise<void>;
+    /**
+     * Start playback
+     */
+    private startPlayback;
+    /**
+     * Pause playback
+     */
+    pausePlayback: () => void;
+    /**
+     * Stop playback
+     */
+    stopPlayback: () => void;
+    /**
+     * Handle playback completion
+     */
+    /**
+     * Handle playback completion
+     */
+    private handlePlaybackComplete;
+    /**
+     * Reset the game
+     */
+    resetGame: () => void;
+    /**
+     * Handle keyboard input for interactive playing
+     */
+    handleKeyboardInput: (event: KeyboardEvent) => void;
+    /**
+     * Preload commonly used instruments
+     */
+    private preloadCommonInstruments;
+    /**
+     * Preload instruments based on current configuration
+     */
+    preloadInstruments: (instrumentTypes: InstrumentType[]) => Promise<void>;
+    handleEditorStateChange: (newState: Partial<MusicState>) => void;
+    handleEditorNotesChange: (notes: (Note | Pause)[]) => void;
+    getCurrentRunResult: () => RunResult;
+    render(): JSX.Element;
+}
+declare const MusicGameWithTranslation: React.ComponentType<Omit<MusicGameProps, keyof WithTranslation> & React.RefAttributes<MusicGame>>;
 export default MusicGameWithTranslation;