@dodona/papyros 0.1.3-action → 0.1.5

package/README.md

@@ -12,29 +12,22 @@
   </a>
 </p>
 
-Papyros is a programming scratchpad in the browser. It allows running arbitrary
-in various programming languages directly in your browser, no installation required.
+Papyros is a programming scratchpad in the browser. It allows running code
+directly in your browser, no installation required. Right now, the focus in on providing a great experience for Python, while also supporting JavaScript.
 By taking away obstacles between students and coding, the learning experience becomes
-smoother and less error-prone. 
-
-Papyros aims to be:
-
-- **Easy to use** by having minimal installation instructions and an intuitive user interface
-- **Flexible** to support many programming languages
+smoother and less error-prone.
 
 Currently, Papyros provides support for the following programming languages:
 - Python, powered by [Pyodide](https://pyodide.org/en/stable/)
 - JavaScript, powered by your browser
 
-## Installation
+## Using Papyros in your own project
 
 You can install Papyros on your system using npm:
 ```shell
 npm install -g @dodona/papyros
 ```
 
-## Usage
-
 Papyros currently supports two modes of operation: stand-alone and embedded.
 
 In stand-alone mode, Papyros runs as a full application in the browser. 

package/{lib → dist}/Backend.d.ts

@@ -6,11 +6,12 @@ export declare abstract class Backend {
     /**
      * Initialize the backend, setting up any globals required
      * @param {function(PapyrosEvent):void} onEvent Callback for when events occur
+     * @param {string} hostname Base URL for input
      * @param {Uint8Array} inputTextArray Optional shared buffer for input
      * @param {Int32Array} inputMetaData Optional shared buffer for metadata about input
      * @return {Promise<void>} Promise of launching
      */
-    launch(onEvent: (e: PapyrosEvent) => void, inputTextArray?: Uint8Array, inputMetaData?: Int32Array): Promise<void>;
+    launch(onEvent: (e: PapyrosEvent) => void, hostname: string, inputTextArray?: Uint8Array, inputMetaData?: Int32Array): Promise<void>;
     abstract _runCodeInternal(code: string): Promise<any>;
     /**
      * Validate and run arbitrary code

package/dist/CodeEditor.d.ts

@@ -0,0 +1,23 @@
+import { LanguageSupport } from "@codemirror/language";
+import { Compartment, Extension } from "@codemirror/state";
+import { ProgrammingLanguage } from "./ProgrammingLanguage";
+import { EditorView } from "@codemirror/view";
+import { RenderOptions } from "./util/Util";
+export declare class CodeEditor {
+    editorView: EditorView;
+    languageCompartment: Compartment;
+    indentCompartment: Compartment;
+    placeholderCompartment: Compartment;
+    panelCompartment: Compartment;
+    constructor(language: ProgrammingLanguage, editorPlaceHolder: string, initialCode?: string, indentLength?: number);
+    render(options: RenderOptions, panel?: HTMLElement): HTMLElement;
+    setLanguage(language: ProgrammingLanguage, editorPlaceHolder: string): void;
+    setIndentLength(indentLength: number): void;
+    setPanel(panel: HTMLElement): void;
+    getCode(): string;
+    setCode(code: string): void;
+    focus(): void;
+    static getIndentUnit(indentLength: number): string;
+    static getLanguageSupport(language: ProgrammingLanguage): LanguageSupport;
+    static getExtensions(): Array<Extension>;
+}

package/{lib → dist}/Constants.d.ts

@@ -4,6 +4,7 @@ export declare const OUTPUT_TA_ID = "code-output-area";
 export declare const INPUT_AREA_WRAPPER_ID = "code-input-area-wrapper";
 export declare const INPUT_TA_ID = "code-input-area";
 export declare const EDITOR_WRAPPER_ID = "code-area";
+export declare const PANEL_WRAPPER_ID = "code-status-panel";
 export declare const STATE_SPINNER_ID = "state-spinner";
 export declare const APPLICATION_STATE_TEXT_ID = "application-state-text";
 export declare const RUN_BTN_ID = "run-code-btn";
@@ -12,6 +13,8 @@ export declare const SEND_INPUT_BTN_ID = "send-input-btn";
 export declare const SWITCH_INPUT_MODE_A_ID = "switch-input-mode";
 export declare const PROGRAMMING_LANGUAGE_SELECT_ID = "programming-language-select";
 export declare const DEFAULT_PROGRAMMING_LANGUAGE = ProgrammingLanguage.Python;
+export declare const EXAMPLE_SELECT_ID = "example-select";
 export declare const LOCALE_SELECT_ID = "locale-select";
 export declare const DEFAULT_LOCALE = "nl";
-export declare const INPUT_RELATIVE_URL = "/__papyros_input";
+export declare const DEFAULT_SERVICE_WORKER = "inputServiceWorker.js";
+export declare const INPUT_RELATIVE_URL = "__papyros_input";

package/{lib → dist}/InputManager.d.ts

@@ -1,4 +1,5 @@
 import { PapyrosEvent } from "./PapyrosEvent";
+import { RenderOptions } from "./util/Util";
 export declare enum InputMode {
     Interactive = "interactive",
     Batch = "batch"
@@ -8,7 +9,7 @@ interface InputSession {
     lineNr: number;
 }
 export declare class InputManager {
-    inputWrapper: HTMLElement;
+    renderOptions: RenderOptions;
     inputMode: InputMode;
     waiting: boolean;
     batchInput: string;
@@ -20,7 +21,7 @@ export declare class InputManager {
     constructor(onSend: () => void, inputMode: InputMode);
     get enterButton(): HTMLButtonElement;
     get inputArea(): HTMLInputElement;
-    buildInputArea(): void;
+    render(options?: RenderOptions): void;
     setInputMode(inputMode: InputMode): void;
     setWaiting(waiting: boolean, prompt?: string): void;
     sendLine(): Promise<boolean>;

package/dist/InputServiceWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/OutputManager.d.ts

@@ -0,0 +1,23 @@
+import { PapyrosEvent } from "./PapyrosEvent";
+import { RenderOptions } from "./util/Util";
+export interface FriendlyError {
+    name: string;
+    traceback?: string;
+    info?: string;
+    why?: string;
+    what?: string;
+    where?: string;
+}
+export declare class OutputManager {
+    outputAreaId: string;
+    options: RenderOptions;
+    get outputArea(): HTMLElement;
+    renderNextElement(html: string): void;
+    spanify(text: string, ignoreEmpty?: boolean): string;
+    showOutput(output: PapyrosEvent): void;
+    showError(error: FriendlyError | string): void;
+    render(options: RenderOptions): HTMLElement;
+    reset(): void;
+    onRunStart(): void;
+    onRunEnd(): void;
+}

package/{lib → dist}/Papyros.d.ts

@@ -5,7 +5,9 @@ import { CodeEditor } from "./CodeEditor";
 import { InputManager, InputMode } from "./InputManager";
 import { PapyrosEvent } from "./PapyrosEvent";
 import { ProgrammingLanguage } from "./ProgrammingLanguage";
+import { RenderOptions } from "./util/Util";
 import { StatusPanel } from "./StatusPanel";
+import { OutputManager } from "./OutputManager";
 declare enum PapyrosState {
     Loading = "loading",
     Running = "running",
@@ -16,17 +18,17 @@ declare enum PapyrosState {
 declare class PapyrosStateManager {
     state: PapyrosState;
     statusPanel: StatusPanel;
-    runButton: HTMLButtonElement;
-    stopButton: HTMLButtonElement;
+    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;
-    outputArea: HTMLInputElement;
 }
 interface PapyrosConfig {
     standAlone: boolean;
@@ -34,20 +36,32 @@ interface PapyrosConfig {
     locale: string;
     inputMode: InputMode;
 }
+interface PapyrosRenderOptions {
+    papyros: RenderOptions;
+    code?: RenderOptions;
+    panel?: RenderOptions;
+    input?: RenderOptions;
+    output?: RenderOptions;
+}
 export declare class Papyros {
     stateManager: PapyrosStateManager;
     codeState: PapyrosCodeState;
     inputManager: InputManager;
+    outputManager: OutputManager;
     constructor(programmingLanguage: ProgrammingLanguage, inputMode: InputMode);
     get state(): PapyrosState;
     launch(): Promise<Papyros>;
     setProgrammingLanguage(programmingLanguage: ProgrammingLanguage): Promise<void>;
+    setCode(code: string): void;
+    getCode(): string;
     startBackend(): Promise<void>;
-    static fromElement(parent: HTMLElement, config: PapyrosConfig): Promise<Papyros>;
+    static fromElement(config: PapyrosConfig, renderOptions: PapyrosRenderOptions): Papyros;
+    static configureInput(allowReload: boolean, serviceWorkerPath: 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;
 }
 export {};

package/{lib → dist}/PapyrosEvent.d.ts

@@ -2,4 +2,5 @@ export interface PapyrosEvent {
     type: "input" | "output" | "script" | "success" | "error";
     data: string;
     runId: number;
+    content?: string;
 }

package/{lib → dist}/StatusPanel.d.ts

@@ -1,10 +1,8 @@
+import { RenderOptions } from "./util/Util";
 export declare class StatusPanel {
-    onRun: () => void;
-    constructor(onRun: () => void);
-    initialize(): void;
     get statusSpinner(): HTMLElement;
     get statusText(): HTMLElement;
     showSpinner(show: boolean): void;
     setStatus(status: string): void;
-    render(parent: HTMLElement): HTMLElement;
+    render(options: RenderOptions): HTMLElement;
 }

package/dist/examples/Examples.d.ts

@@ -0,0 +1,6 @@
+import { ProgrammingLanguage } from "../ProgrammingLanguage";
+export declare function getExamples(language: ProgrammingLanguage): {
+    [key: string]: string;
+};
+export declare function getExampleNames(language: ProgrammingLanguage): Array<string>;
+export declare function getCodeForExample(language: ProgrammingLanguage, name: string): string;

package/dist/examples/JavaScriptExamples.d.ts

@@ -0,0 +1,5 @@
+export declare const JAVASCRIPT_EXAMPLES: {
+    "Hello world!": string;
+    Input: string;
+    Fibonacci: string;
+};

package/dist/examples/PythonExamples.d.ts

@@ -0,0 +1,11 @@
+export declare const PYTHON_EXAMPLES: {
+    "Hello, World!": string;
+    Input: string;
+    Fibonacci: string;
+    Doctests: string;
+    Async: string;
+    Erroneous: string;
+    Unicode: string;
+    Files: string;
+    Matplotlib: string;
+};