@dodona/papyros 0.1.61 → 0.1.91-tar

package/dist/Papyros.d.ts

@@ -1,69 +1,142 @@
 import "./Papyros.css";
-import { Remote } from "comlink";
-import { Backend } from "./Backend";
-import { CodeEditor } from "./CodeEditor";
-import { InputManager, InputMode } from "./InputManager";
-import { PapyrosEvent } from "./PapyrosEvent";
+import { InputMode } from "./InputManager";
 import { ProgrammingLanguage } from "./ProgrammingLanguage";
-import { RenderOptions } from "./util/Util";
-import { StatusPanel } from "./StatusPanel";
+import { RenderOptions, ButtonOptions } from "./util/Util";
+import { RunState, CodeRunner } from "./CodeRunner";
 import { OutputManager } from "./OutputManager";
-declare enum PapyrosState {
-    Loading = "loading",
-    Running = "running",
-    AwaitingInput = "awaiting_input",
-    Stopping = "stopping",
-    Ready = "ready"
-}
-declare class PapyrosStateManager {
-    state: PapyrosState;
-    statusPanel: StatusPanel;
-    get runButton(): HTMLButtonElement;
-    get stopButton(): HTMLButtonElement;
-    constructor(statusPanel: StatusPanel);
-    setState(state: PapyrosState, message?: string): void;
-    render(options: RenderOptions): HTMLElement;
-}
-interface PapyrosCodeState {
-    programmingLanguage: ProgrammingLanguage;
-    editor: CodeEditor;
-    backend: Remote<Backend>;
-    runId: number;
-}
+/**
+ * Configuration options for this instance of Papyros
+ */
 interface PapyrosConfig {
+    /**
+     * Whether Papyros is run in standAlone mode or embedded in an application
+     */
     standAlone: boolean;
+    /**
+     * The programming language to use
+     */
     programmingLanguage: ProgrammingLanguage;
+    /**
+     * The language to use
+     */
     locale: string;
+    /**
+     * The InputMode to use
+     */
     inputMode: InputMode;
 }
+/**
+ * Options for rendering Papyros
+ */
 interface PapyrosRenderOptions {
-    papyros?: RenderOptions;
-    code?: RenderOptions;
-    panel?: RenderOptions;
-    input?: RenderOptions;
-    output?: RenderOptions;
+    /**
+     * Options to render Papyros itself, only used in standAlone mode
+     */
+    standAloneOptions?: RenderOptions;
+    /**
+     * RenderOptions for the code editor
+     */
+    codeEditorOptions?: RenderOptions;
+    /**
+     * RenderOptions for the status panel in the editor
+     */
+    statusPanelOptions?: RenderOptions;
+    /**
+     * RenderOptions for the input field
+     */
+    inputOptions?: RenderOptions;
+    /**
+     * RenderOptions for the output field
+     */
+    outputOptions?: RenderOptions;
 }
+/**
+ * Class that manages multiple components to form a coding scratchpad
+ */
 export declare class Papyros {
-    stateManager: PapyrosStateManager;
-    codeState: PapyrosCodeState;
-    inputManager: InputManager;
+    /**
+     * Config used to initialize Papyros
+     */
+    config: PapyrosConfig;
+    /**
+     * Component to run code entered by the user
+     */
+    codeRunner: CodeRunner;
+    /**
+     * Component to handle output generated by the user's code
+     */
     outputManager: OutputManager;
-    constructor(programmingLanguage: ProgrammingLanguage, inputMode: InputMode);
-    get state(): PapyrosState;
+    /**
+     * Whether this instance has been launched
+     */
+    private launched;
+    /**
+     * Construct a new Papyros instance
+     * @param {PapyrosConfig} config Properties to configure this instance
+     */
+    constructor(config: PapyrosConfig);
+    /**
+     * @return {RunState} The current state of the user's code
+     */
+    getState(): RunState;
+    /**
+     * Launch this instance of Papyros, making it ready to run code
+     * @return {Promise<Papyros>} Promise of launching, chainable
+     */
     launch(): Promise<Papyros>;
+    /**
+     * 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>;
+    /**
+     * @param {string} code The code to use in the editor
+     */
     setCode(code: string): void;
+    /**
+     * @return {string} The currently written code
+     */
     getCode(): string;
-    startBackend(): Promise<void>;
-    static fromElement(config: PapyrosConfig, renderOptions: PapyrosRenderOptions): Papyros;
-    configureInput(allowReload: boolean, serviceWorkerRoot?: string, serviceWorkerName?: string): Promise<boolean>;
-    onError(e: PapyrosEvent): void;
-    onInput(e: PapyrosEvent): Promise<void>;
-    onMessage(e: PapyrosEvent): void;
-    runCode(): Promise<void>;
-    stop(): Promise<void>;
-    render(standAlone: boolean, programmingLanguage: ProgrammingLanguage, locale: string, renderOptions: PapyrosRenderOptions): void;
+    /**
+     * Helper method to perform the service worker related checks and initialisation
+     * @param {string} serviceWorkerRoot URL for the directory where the service worker lives
+     * @param {string} serviceWorkerName The name of the file containing the script
+     * @return {Promise<boolean>} Whether registration was successful
+     */
+    private registerServiceWorker;
+    /**
+     * Configure how user input is handled within Papyros
+     * By default, we will try to use SharedArrayBuffers
+     * If this option is not available, the optional arguments become relevant
+     * They are needed to register a service worker to handle communication between threads
+     * @param {string} serviceWorkerRoot URL for the directory where the service worker lives
+     * @param {string} serviceWorkerName The name of the file containing the script
+     * @param {boolean} allowReload Whether we are allowed to force a reload of the page
+     * This allows using SharedArrayBuffers without configuring the HTTP headers yourself
+     * @return {Promise<boolean>} Promise of configuring input
+     */
+    configureInput(serviceWorkerRoot?: string, serviceWorkerName?: string, allowReload?: boolean): Promise<boolean>;
+    /**
+     * Render Papyros with the given options
+     * @param {PapyrosRenderOptions} renderOptions Options to use
+     */
+    render(renderOptions: PapyrosRenderOptions): void;
+    /**
+     * Add a button to the status panel within Papyros
+     * @param {ButtonOptions} options Options to render the button with
+     * @param {function} onClick Listener for click events on the button
+     */
+    addButton(options: ButtonOptions, onClick: () => void): void;
+    /**
+     * @param {ProgrammingLanguage} language The language to check
+     * @return {boolean} Whether Papyros supports this language by default
+     */
     static supportsProgrammingLanguage(language: string): boolean;
+    /**
+     * Convert a string to a ProgrammingLanguage
+     * @param {string} language The language to convert
+     * @return {ProgrammingLanguage | undefined} The ProgrammingLanguage, or undefined if not supported
+     */
     static toProgrammingLanguage(language: string): ProgrammingLanguage | undefined;
 }
 export {};

package/dist/ProgrammingLanguage.d.ts

@@ -1,3 +1,6 @@
+/**
+ * String enum representing programming languages supported by Papyros
+ */
 export declare enum ProgrammingLanguage {
     Python = "Python",
     JavaScript = "JavaScript"

package/dist/RunListener.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Interface for components that maintain state based on runs of code
+ */
+export interface RunListener {
+    /**
+     * Inform this listener that a new run started
+     */
+    onRunStart(): void;
+    /**
+     * Inform this listener that the run ended
+     */
+    onRunEnd(): void;
+}

package/dist/examples/PythonExamples.d.ts

@@ -8,4 +8,5 @@ export declare const PYTHON_EXAMPLES: {
     Unicode: string;
     Files: string;
     Matplotlib: string;
+    Sleep: string;
 };