@dodona/papyros 0.1.91-tar → 0.1.94

package/dist/Backend.d.ts

@@ -34,25 +34,19 @@ export interface WorkerAutocompleteContext {
         text: string;
     } | null;
 }
-export declare abstract class Backend {
-    protected syncExtras: SyncExtras;
+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
-     *  These are then exposed via Comlink. Proper initialization occurs
-     *  in the launch method when the worker is started
-     * @param {Array<string>} syncMethods The methods to expose
+     * 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(syncMethods?: string[]);
+    constructor();
     /**
      * @return {any} The function to expose methods for Comsync to allow interrupting
      */
     protected syncExpose(): any;
-    /**
-     * Expose all the methods that should support being interrupted
-     * @param {Array<string>} syncMethods The names of the methods to expose
-     */
-    protected exposeMethods(syncMethods: Array<string>): void;
     /**
      * Initialize the backend by doing all setup-related work
      * @param {function(BackendEvent):void} onEvent Callback for when events occur
@@ -61,13 +55,15 @@ export declare abstract class Backend {
     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
      * @return {Promise<void>} Promise of execution
      */
-    abstract runCode(extras: SyncExtras, code: string): Promise<void>;
+    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

package/dist/BackendEvent.d.ts

@@ -25,9 +25,9 @@ export interface BackendEvent {
     /**
      * The actual data stored in this event
      */
-    data: string;
+    data: any;
     /**
      * The format used for the data to help with parsing
      */
-    contentType: string;
+    contentType?: string;
 }

package/dist/BackendManager.d.ts

@@ -8,29 +8,37 @@ import { SyncClient } from "comsync";
  * @param {BackendEvent} e The published event
  */
 declare type BackendEventListener = (e: BackendEvent) => void;
-declare class Cacheable<T> {
-    private cached;
-    private createFn;
-    constructor(createFn: () => T);
-    get(): T;
-}
 /**
  * Abstract class to implement the singleton pattern
  * Static methods group functionality
  */
 export declare abstract class BackendManager {
-    static createWorkerMap: Map<ProgrammingLanguage, Cacheable<SyncClient<Backend>>>;
-    static channel: Channel;
+    /**
+     * 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>>;
-    private static buildSyncClientMap;
     /**
-     * Start a backend for the given language, while storing the worker
+     * 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 {Remote<Backend>} A Comlink proxy for the Backend
+     * @return {SyncClient<Backend>} A SyncClient for the Backend
      */
     static startBackend(language: ProgrammingLanguage): SyncClient<Backend>;
     /**

package/dist/Constants.d.ts

@@ -17,4 +17,4 @@ export declare const LOCALE_SELECT_ID: string;
 export declare const PROGRAMMING_LANGUAGE_SELECT_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_SERVICE_WORKER = "InputServiceWorker.js";

package/dist/Library.d.ts

@@ -4,7 +4,6 @@ import { InputManager, InputMode } from "./InputManager";
 import { OutputManager } from "./OutputManager";
 import { Papyros } from "./Papyros";
 import { CodeRunner, RunState } from "./CodeRunner";
-import { InputWorker } from "./workers/input/InputWorker";
 export * from "./ProgrammingLanguage";
 export type { BackendEvent };
-export { Papyros, CodeEditor, RunState, CodeRunner, InputManager, InputMode, OutputManager, InputWorker };
+export { Papyros, CodeEditor, RunState, CodeRunner, InputManager, InputMode, OutputManager, };