@dodona/papyros 0.3.6 → 0.4.0-es6

package/dist/Backend.d.ts

@@ -62,6 +62,10 @@ export interface WorkerDiagnostic {
      */
     message: string;
 }
+export interface RunMode {
+    mode: string;
+    active: boolean;
+}
 export declare abstract class Backend<Extras extends SyncExtras = SyncExtras> {
     /**
      * SyncExtras object that grants access to helpful methods
@@ -89,16 +93,24 @@ export declare abstract class Backend<Extras extends SyncExtras = SyncExtras> {
     /**
      * Initialize the backend by doing all setup-related work
      * @param {function(BackendEvent):void} onEvent Callback for when events occur
+     * @param {function():void} onOverflow Callback for when overflow occurs
      * @return {Promise<void>} Promise of launching
      */
-    launch(onEvent: (e: BackendEvent) => void): Promise<void>;
+    launch(onEvent: (e: BackendEvent) => void, onOverflow: () => void): Promise<void>;
+    /**
+     * Determine whether the modes supported by this Backend are active
+     * @param {string} code The current code in the editor
+     * @return {Array<RunMode>} The run modes of this Backend
+     */
+    runModes(code: string): Array<RunMode>;
     /**
      * Executes the given code
      * @param {Extras} extras Helper properties to run code
      * @param {string} code The code to run
+     * @param {string} mode The mode to run the code in
      * @return {Promise<void>} Promise of execution
      */
-    abstract runCode(extras: Extras, code: string): Promise<void>;
+    abstract runCode(extras: Extras, code: string, mode?: string): Promise<void>;
     /**
      * Converts the context to a cloneable object containing useful properties
      * to generate autocompletion suggestions with

package/dist/BackendEventQueue.d.ts

@@ -25,6 +25,14 @@ export declare class BackendEventQueue {
      * Queue storing Output-events after overflowing
      */
     private overflow;
+    /**
+     * Callback for when overflow occurs
+     */
+    private onOverflow;
+    /**
+     * Keep track whether the queue reached its limit this run
+     */
+    private overflown;
     /**
      * Time in milliseconds when the last flush occurred
      */
@@ -38,11 +46,12 @@ export declare class BackendEventQueue {
      */
     private decoder;
     /**
-     * @param {Function} callback Function to process events in the queue
+     * @param {function(BackendEvent):void} callback Function to process events in the queue
+     * @param {function():void} onOverflow Callback for when overflow occurs
      * @param {number} limit The maximal amount of output lines to send before overflowing
      * @param {number} flushTime The time in milliseconds before sending events through
      */
-    constructor(callback: (e: BackendEvent) => void, limit?: number, flushTime?: number);
+    constructor(callback: (e: BackendEvent) => void, onOverflow: () => void, limit?: number, flushTime?: number);
     /**
      * Add an element to the queue
      * @param {BackendEventType} type The type of the event

package/dist/CodeRunner.d.ts

@@ -1,7 +1,8 @@
-import { CodeEditor } from "./CodeEditor";
-import { InputManager } from "./InputManager";
+import { CodeEditor } from "./editor/CodeEditor";
+import { InputManager, InputMode } from "./InputManager";
 import { ProgrammingLanguage } from "./ProgrammingLanguage";
 import { RenderOptions, ButtonOptions, Renderable } from "./util/Rendering";
+import { OutputManager } from "./OutputManager";
 interface CodeRunnerRenderOptions {
     /**
      * Options for rendering the panel
@@ -15,6 +16,10 @@ interface CodeRunnerRenderOptions {
      * Options for rendering the editor
      */
     codeEditorOptions: RenderOptions;
+    /**
+     * RenderOptions for the output field
+     */
+    outputOptions: RenderOptions;
 }
 /**
  * Enum representing the possible states while processing code
@@ -55,6 +60,10 @@ export declare class CodeRunner extends Renderable<CodeRunnerRenderOptions> {
      * Component to request and handle input from the user
      */
     readonly inputManager: InputManager;
+    /**
+     * Component to handle output generated by the user's code
+     */
+    readonly outputManager: OutputManager;
     /**
      * The backend that executes the code asynchronously
      */
@@ -78,8 +87,9 @@ export declare class CodeRunner extends Renderable<CodeRunnerRenderOptions> {
     /**
      * Construct a new RunStateManager with the given listeners
      * @param {ProgrammingLanguage} programmingLanguage The language to use
+     * @param {InputMode} inputMode The input mode to use
      */
-    constructor(programmingLanguage: ProgrammingLanguage);
+    constructor(programmingLanguage: ProgrammingLanguage, inputMode: InputMode);
     /**
      * Start the backend to enable running code
      */
@@ -115,18 +125,21 @@ export declare class CodeRunner extends Renderable<CodeRunnerRenderOptions> {
      */
     setState(state: RunState, message?: string): void;
     getState(): RunState;
+    removeButton(id: string): void;
     /**
      * Add a button to display to the user
      * @param {ButtonOptions} options Options for rendering the button
      * @param {function} onClick Listener for click events on the button
      */
     addButton(options: ButtonOptions, onClick: () => void): void;
+    private renderButtons;
     protected _render(options: CodeRunnerRenderOptions): HTMLElement;
     /**
      * @param {string} code The code to run
+     * @param {string} mode The mode to run with
      * @return {Promise<void>} Promise of running the code
      */
-    runCode(code: string): Promise<void>;
+    runCode(code: string, mode?: string): Promise<void>;
     /**
      * Callback to handle loading events
      * @param {BackendEvent} e The loading event

package/dist/Constants.d.ts

@@ -16,6 +16,7 @@ export declare const EDITOR_WRAPPER_ID: string;
 export declare const PANEL_WRAPPER_ID: string;
 export declare const STATE_SPINNER_ID: string;
 export declare const APPLICATION_STATE_TEXT_ID: string;
+export declare const CODE_BUTTONS_WRAPPER_ID: string;
 export declare const RUN_BTN_ID: string;
 export declare const STOP_BTN_ID: string;
 export declare const SEND_INPUT_BTN_ID: string;
@@ -27,3 +28,4 @@ export declare const DARK_MODE_TOGGLE_ID: string;
 export declare const DEFAULT_PROGRAMMING_LANGUAGE = ProgrammingLanguage.Python;
 export declare const DEFAULT_LOCALE = "nl";
 export declare const DEFAULT_SERVICE_WORKER = "InputServiceWorker.js";
+export declare const DEFAULT_EDITOR_DELAY = 750;

package/dist/InputManager.d.ts

@@ -1,3 +1,4 @@
+import { UserInputHandler } from "./input/UserInputHandler";
 import { Renderable, RenderOptions } from "./util/Rendering";
 export declare enum InputMode {
     Interactive = "interactive",
@@ -10,11 +11,11 @@ export declare class InputManager extends Renderable {
     private waiting;
     private prompt;
     private sendInput;
-    constructor(sendInput: (input: string) => void);
+    constructor(sendInput: (input: string) => void, inputMode: InputMode);
     private buildInputHandlerMap;
     getInputMode(): InputMode;
     setInputMode(inputMode: InputMode): void;
-    private get inputHandler();
+    get inputHandler(): UserInputHandler;
     isWaiting(): boolean;
     protected _render(options: RenderOptions): void;
     private waitWithPrompt;
@@ -22,7 +23,6 @@ export declare class InputManager extends Renderable {
     /**
      * Asynchronously handle an input request by prompting the user for input
      * @param {BackendEvent} e Event containing the input data
-     * @return {Promise<void>} Promise of handling the request
      */
     private onInputRequest;
     private onRunStart;

package/dist/Library.d.ts

@@ -1,5 +1,5 @@
 import { BackendEvent } from "./BackendEvent";
-import { CodeEditor } from "./CodeEditor";
+import { CodeEditor } from "./editor/CodeEditor";
 import { InputManager, InputMode } from "./InputManager";
 import { FriendlyError, OutputManager } from "./OutputManager";
 import { Papyros, PapyrosConfig, PapyrosRenderOptions } from "./Papyros";