@dodona/papyros 0.1.90 → 0.1.93

package/dist/Backend.d.ts

@@ -1,32 +1,77 @@
-import { PapyrosEvent } from "./PapyrosEvent";
-import { Channel } from "sync-message";
-export declare abstract class Backend {
-    protected onEvent: (e: PapyrosEvent) => any;
-    protected runId: number;
+import { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+import { BackendEvent } from "./BackendEvent";
+import { SyncExtras } from "comsync";
+/**
+ * Interface to represent the CodeMirror CompletionContext in a worker
+ */
+export interface WorkerAutocompleteContext {
     /**
-     *  Constructor is limited as it is meant to be used as a WebWorker
-     *  These are then exposed via Comlink. Proper initialization occurs
-     *  in the launch method when the worker is started
+     * Whether the autocompletion was explicitly requested (using keybindings)
+     */
+    explicit: boolean;
+    /**
+     * The absolute position in the CodeMirror document
+     */
+    pos: number;
+    /**
+     * The line number of the cursor while completing (1-based)
+     */
+    line: number;
+    /**
+     * The column number of the cursor while completing (1-based)
+     */
+    column: number;
+    /**
+     * The full text to autocomplete for
+     */
+    text: string;
+    /**
+     * The match before the cursor (determined by a regex)
+     */
+    before: {
+        from: number;
+        to: number;
+        text: string;
+    } | null;
+}
+export declare abstract class Backend<Extras extends SyncExtras = SyncExtras> {
+    protected extras: Extras;
+    protected onEvent: (e: BackendEvent) => any;
+    /**
+     * Constructor is limited as it is meant to be used as a WebWorker
+     * Proper initialization occurs in the launch method when the worker is started
+     * Synchronously exposing methods should be done here
      */
     constructor();
     /**
-     * Initialize the backend by doing all setup-related work
-     * @param {function(PapyrosEvent):void} onEvent Callback for when events occur
-     * @param {Channel} channel for communication with the main thread
-     * @return {Promise<void>} Promise of launching
+     * @return {any} The function to expose methods for Comsync to allow interrupting
      */
-    launch(onEvent: (e: PapyrosEvent) => void, channel: Channel): Promise<void>;
+    protected syncExpose(): any;
     /**
-     * Internal helper method that actually executes the code
-     * Results or Errors must be passed by using the onEvent-callback
-     * @param code The code to run
+     * Initialize the backend by doing all setup-related work
+     * @param {function(BackendEvent):void} onEvent Callback for when events occur
+     * @return {Promise<void>} Promise of launching
      */
-    protected abstract _runCodeInternal(code: string): Promise<any>;
+    launch(onEvent: (e: BackendEvent) => void): Promise<void>;
     /**
      * Executes the given code
+     * @param {Extras} extras Helper properties to run code
      * @param {string} code The code to run
-     * @param {string} runId The uuid for this execution
      * @return {Promise<void>} Promise of execution
      */
-    runCode(code: string, runId: number): Promise<any>;
+    abstract runCode(extras: Extras, code: string): Promise<void>;
+    /**
+     * Converts the context to a cloneable object containing useful properties
+     * to generate autocompletion suggestions with
+     * Class instances are not passable to workers, so we extract the useful information
+     * @param {CompletionContext} context Current context to autocomplete for
+     * @param {RegExp} expr Expression to match the previous token with
+     * @return {WorkerAutocompleteContext} Completion context that can be passed as a message
+     */
+    static convertCompletionContext(context: CompletionContext, expr?: RegExp): WorkerAutocompleteContext;
+    /**
+     * Generate autocompletion suggestions for the given context
+     * @param {WorkerAutocompleteContext} context Context to autcomplete in
+     */
+    abstract autocomplete(context: WorkerAutocompleteContext): Promise<CompletionResult | null>;
 }

package/dist/BackendEvent.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Enum representing all possible types for supported events
+ */
+export declare enum BackendEventType {
+    Start = "start",
+    End = "end",
+    Input = "input",
+    Output = "output",
+    Sleep = "sleep",
+    Error = "error",
+    Interrupt = "interrupt"
+}
+/**
+ * All possible types for ease of iteration
+ */
+export declare const BACKEND_EVENT_TYPES: BackendEventType[];
+/**
+ * Interface for events used for communication between threads
+ */
+export interface BackendEvent {
+    /**
+     * The type of action generating this event
+     */
+    type: BackendEventType;
+    /**
+     * The actual data stored in this event
+     */
+    data: any;
+    /**
+     * The format used for the data to help with parsing
+     */
+    contentType?: string;
+}

package/dist/BackendManager.d.ts

@@ -1,14 +1,57 @@
-import { Remote } from "comlink";
 import { Backend } from "./Backend";
 import { ProgrammingLanguage } from "./ProgrammingLanguage";
+import { BackendEvent, BackendEventType } from "./BackendEvent";
+import { Channel } from "sync-message";
+import { SyncClient } from "comsync";
 /**
- * Start a backend for the given language, while storing the worker
- * @param {ProgrammingLanguage} language The programming language supported by the backend
- * @return {Remote<Backend>} A Comlink proxy for the Backend
+ * Callback type definition for subscribers
+ * @param {BackendEvent} e The published event
  */
-export declare function startBackend(language: ProgrammingLanguage): Remote<Backend>;
+declare type BackendEventListener = (e: BackendEvent) => void;
 /**
- * Stop a backend by terminating the worker and releasing memory
- * @param {Remote<Backend>} backend The proxy for the backend to stop
+ * Abstract class to implement the singleton pattern
+ * Static methods group functionality
  */
-export declare function stopBackend(backend: Remote<Backend>): void;
+export declare abstract class BackendManager {
+    /**
+     * Map programming languages to Backend constructors
+     */
+    private static createBackendMap;
+    /**
+     * Map to cache Backends per ProgrammingLanguage
+     */
+    private static backendMap;
+    /**
+     * Map an event type to interested subscribers
+     * Uses an Array to maintain order of subscription
+     */
+    static subscriberMap: Map<BackendEventType, Array<BackendEventListener>>;
+    /**
+     * The channel used to communicate with the SyncClients
+     */
+    static channel: Channel;
+    /**
+     * @param {ProgrammingLanguage} language The language to support
+     * @param {Function} backendCreator The constructor for a SyncClient
+     */
+    static registerBackend(language: ProgrammingLanguage, backendCreator: () => SyncClient<Backend>): void;
+    /**
+     * Start a backend for the given language and cache for reuse
+     * @param {ProgrammingLanguage} language The programming language supported by the backend
+     * @return {SyncClient<Backend>} A SyncClient for the Backend
+     */
+    static startBackend(language: ProgrammingLanguage): SyncClient<Backend>;
+    /**
+     * Register a callback for when an event of a certain type is published
+     * @param {BackendEventType} type The type of event to subscribe to
+     * @param {BackendEventListener} subscriber Callback for when an event
+     * of the given type is published
+     */
+    static subscribe(type: BackendEventType, subscriber: BackendEventListener): void;
+    /**
+     * Publish an event, notifying all listeners for its type
+     * @param {BackendEventType} e The event to publish
+     */
+    static publish(e: BackendEvent): void;
+}
+export {};

package/dist/CodeEditor.d.ts

@@ -2,6 +2,7 @@ import { LanguageSupport } from "@codemirror/language";
 import { Compartment, Extension } from "@codemirror/state";
 import { ProgrammingLanguage } from "./ProgrammingLanguage";
 import { EditorView } from "@codemirror/view";
+import { CompletionSource } from "@codemirror/autocomplete";
 import { RenderOptions } from "./util/Util";
 /**
  * Component that provides useful features to users writing code
@@ -27,6 +28,10 @@ export declare class CodeEditor {
     * Compartment to configure the panel at runtime
      */
     panelCompartment: Compartment;
+    /**
+     * Compartment to configure the autocompletion at runtime
+     */
+    autocompletionCompartment: Compartment;
     /**
      * Construct a new CodeEditor
      * @param {ProgrammingLanguage} language The used programming language
@@ -34,7 +39,7 @@ export declare class CodeEditor {
      * @param {string} initialCode The initial code to display
      * @param {number} indentLength The length in spaces for the indent unit
      */
-    constructor(language: ProgrammingLanguage, editorPlaceHolder: string, initialCode?: string, indentLength?: number);
+    constructor(initialCode?: string, indentLength?: number);
     /**
      * Render the editor with the given options and panel
      * @param {RenderOptions} options Options for rendering
@@ -43,11 +48,14 @@ export declare class CodeEditor {
      */
     render(options: RenderOptions, panel?: HTMLElement): HTMLElement;
     /**
-     * Set the language that is currently used, with a corresponding placeholder
+     * Set the language that is currently used
      * @param {ProgrammingLanguage} language The language to use
-     * @param {string} editorPlaceHolder Placeholder when empty
      */
-    setLanguage(language: ProgrammingLanguage, editorPlaceHolder: string): void;
+    setLanguage(language: ProgrammingLanguage): void;
+    /**
+     * @param {CompletionSource} completionSource Function to obtain autocomplete results
+     */
+    setCompletionSource(completionSource: CompletionSource): void;
     /**
      * Set the length in spaces of the indentation unit
      * @param {number} indentLength The number of spaces to use

package/dist/CodeRunner.d.ts

@@ -0,0 +1,102 @@
+import { CodeEditor } from "./CodeEditor";
+import { InputManager } from "./InputManager";
+import { ProgrammingLanguage } from "./ProgrammingLanguage";
+import { ButtonOptions, RenderOptions } from "./util/Util";
+/**
+ * Enum representing the possible states while processing code
+ */
+export declare enum RunState {
+    Loading = "loading",
+    Running = "running",
+    AwaitingInput = "awaiting_input",
+    Stopping = "stopping",
+    Ready = "ready"
+}
+/**
+ * Helper component to manage and visualize the current RunState
+ */
+export declare class CodeRunner {
+    /**
+     * The currently used programming language
+     */
+    private programmingLanguage;
+    /**
+     * The editor in which the code is written
+     */
+    readonly editor: CodeEditor;
+    /**
+     * Component to request and handle input from the user
+     */
+    readonly inputManager: InputManager;
+    /**
+     * The backend that executes the code asynchronously
+     */
+    private backend;
+    /**
+     * Current state of the program
+     */
+    private state;
+    /**
+     * Buttons managed by this component
+     */
+    private buttons;
+    /**
+     * Construct a new RunStateManager with the given listeners
+     * @param {ProgrammingLanguage} programmingLanguage The language to use
+     */
+    constructor(programmingLanguage: ProgrammingLanguage);
+    /**
+     * Start the backend to enable running code
+     */
+    start(): Promise<void>;
+    /**
+     * Interrupt the currently running code
+     * @return {Promise<void>} Promise of stopping
+     */
+    stop(): Promise<void>;
+    /**
+     * Set the used programming language to the given one to allow editing and running code
+     * @param {ProgrammingLanguage} programmingLanguage The language to use
+     */
+    setProgrammingLanguage(programmingLanguage: ProgrammingLanguage): Promise<void>;
+    getProgrammingLanguage(): ProgrammingLanguage;
+    /**
+     * Get the button to run the code
+     */
+    get runButton(): HTMLButtonElement;
+    /**
+     * Get the button to interrupt the code
+     */
+    get stopButton(): HTMLButtonElement;
+    /**
+     * Show or hide the spinning circle, representing a running animation
+     * @param {boolean} show Whether to show the spinner
+     */
+    showSpinner(show: boolean): void;
+    /**
+     * Show the current state of the program to the user
+     * @param {RunState} state The current state of the run
+     * @param {string} message Optional message to indicate the state
+     */
+    setState(state: RunState, message?: string): void;
+    getState(): RunState;
+    /**
+     * 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;
+    /**
+     * Render the RunStateManager with the given options
+     * @param {RenderOptions} statusPanelOptions Options for rendering the panel
+     * @param {RenderOptions} inputOptions Options for rendering the InputManager
+     * @param {RenderOptions} codeEditorOptions Options for rendering the editor
+     * @return {HTMLElement} The rendered RunStateManager
+     */
+    render(statusPanelOptions: RenderOptions, inputOptions: RenderOptions, codeEditorOptions: RenderOptions): HTMLElement;
+    /**
+     * Run the code that is currently present in the editor
+     * @return {Promise<void>} Promise of running the code
+     */
+    runCode(): Promise<void>;
+}

package/dist/InputManager.d.ts

@@ -1,40 +1,32 @@
-import { PapyrosEvent } from "./PapyrosEvent";
+import { BackendEvent } from "./BackendEvent";
 import { RenderOptions } from "./util/Util";
-import { Channel } from "sync-message";
 import { UserInputHandler } from "./input/UserInputHandler";
-import { RunListener } from "./RunListener";
 export declare enum InputMode {
     Interactive = "interactive",
     Batch = "batch"
 }
 export declare const INPUT_MODES: InputMode[];
-export interface InputData {
-    prompt: string;
-    messageId: string;
-}
-export declare class InputManager implements RunListener {
-    private _inputMode;
+export declare class InputManager {
+    private inputMode;
     private inputHandlers;
     private renderOptions;
-    _waiting: boolean;
-    prompt: string;
-    onSend: () => void;
-    channel: Channel;
-    messageId: string;
-    constructor(onSend: () => void, inputMode: InputMode);
+    private waiting;
+    private prompt;
+    private sendInput;
+    constructor(sendInput: (input: string) => void);
     private buildInputHandlerMap;
-    get inputMode(): InputMode;
-    set inputMode(inputMode: InputMode);
+    getInputMode(): InputMode;
+    setInputMode(inputMode: InputMode): void;
     get inputHandler(): UserInputHandler;
     render(options: RenderOptions): void;
-    set waiting(waiting: boolean);
-    sendLine(): Promise<void>;
+    waitWithPrompt(waiting: boolean, prompt?: string): void;
+    onUserInput(): Promise<void>;
     /**
      * Asynchronously handle an input request by prompting the user for input
-     * @param {PapyrosEvent} e Event containing the input data
+     * @param {BackendEvent} e Event containing the input data
      * @return {Promise<void>} Promise of handling the request
      */
-    onInput(e: PapyrosEvent): Promise<void>;
+    onInputRequest(e: BackendEvent): Promise<void>;
     onRunStart(): void;
     onRunEnd(): void;
 }

package/dist/Library.d.ts

@@ -1,10 +1,9 @@
+import { BackendEvent } from "./BackendEvent";
 import { CodeEditor } from "./CodeEditor";
 import { InputManager, InputMode } from "./InputManager";
 import { OutputManager } from "./OutputManager";
 import { Papyros } from "./Papyros";
-import { PapyrosEvent } from "./PapyrosEvent";
-import { RunStateManager, RunState } from "./RunStateManager";
-import { InputWorker } from "./workers/input/InputWorker";
+import { CodeRunner, RunState } from "./CodeRunner";
 export * from "./ProgrammingLanguage";
-export type { PapyrosEvent };
-export { Papyros, CodeEditor, RunState, RunStateManager, InputManager, InputMode, OutputManager, InputWorker };
+export type { BackendEvent };
+export { Papyros, CodeEditor, RunState, CodeRunner, InputManager, InputMode, OutputManager, };