@casual-simulation/aux-common 3.1.8 → 3.1.9-alpha.3340590989

package/runtime/AuxRuntime.d.ts

@@ -2,26 +2,34 @@ import { BotAction, StateUpdatedEvent, Bot, BotSpace, RuntimeBot, CompiledBotLis
 import { Observable, SubscriptionLike } from 'rxjs';
 import { AuxGlobalContext } from './AuxGlobalContext';
 import { AuxLibrary } from './AuxLibrary';
-import { RuntimeBotInterface, RuntimeBotFactory, RealtimeEditMode, RealtimeEditConfig } from './RuntimeBot';
-import { CompiledBot, CompiledBotsState } from './CompiledBot';
+import { RuntimeBotInterface, RuntimeBotFactory, RealtimeEditMode, RealtimeEditConfig, RuntimeInterpreterGeneratorProcessor } from './RuntimeBot';
+import { CompiledBot, CompiledBotsState, RuntimeBreakpoint, RuntimeStop } from './CompiledBot';
 import { ScriptError, ActionResult } from './AuxResults';
 import { AuxVersion } from './AuxVersion';
 import { AuxDevice } from './AuxDevice';
+import { RuntimePromise } from './Utils';
 import { AuxRealtimeEditModeProvider } from './AuxRealtimeEditModeProvider';
 import { CurrentVersion } from '@casual-simulation/causal-trees';
 import { RuntimeStateVersion } from './RuntimeStateVersion';
+import type { Interpreter as InterpreterType, InterpreterContinuation, InterpreterStop } from '@casual-simulation/js-interpreter';
+export declare function registerInterpreterModule(module: any): void;
 /**
  * Defines an class that is able to manage the runtime state of an AUX.
  *
  * Being a runtime means providing and managing the execution state that an AUX is in.
  * This means taking state updates events, shouts and whispers, and emitting additional events to affect the future state.
  */
-export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactory, SubscriptionLike {
+export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactory, RuntimeInterpreterGeneratorProcessor, SubscriptionLike {
     private _compiledState;
     private _existingMasks;
     private _compiler;
     private _onActions;
     private _onErrors;
+    private _onRuntimeStop;
+    private _stopState;
+    private _breakpoints;
+    private _currentStopCount;
+    private _currentPromise;
     private _actionBatch;
     private _errorBatch;
     private _userId;
@@ -35,11 +43,15 @@ export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactor
     private _forceSignedScripts;
     private _exemptSpaces;
     private _batchPending;
+    private _jobQueueCheckPending;
+    private _jobQueueCheckCount;
     private _processingErrors;
     private _portalBots;
     private _builtinPortalBots;
     private _globalChanges;
     private _globalObject;
+    private _interpretedApi;
+    private _interpretedTagSpecificApi;
     /**
      * The counter that is used to generate function names.
      */
@@ -59,17 +71,20 @@ export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactor
     private _forceSyncScripts;
     private _currentDebugger;
     private _libraryFactory;
+    private _interpreter;
     get forceSignedScripts(): boolean;
     get context(): AuxGlobalContext;
     get currentVersion(): RuntimeStateVersion;
     get globalObject(): any;
+    get canTriggerBreakpoint(): boolean;
     /**
      * Creates a new AuxRuntime using the given library factory.
      * @param libraryFactory
      * @param forceSignedScripts Whether to force the runtime to only allow scripts that are signed.
      * @param exemptSpaces The spaces that are exempt from requiring signed scripts.
+     * @param interpreter The interpreter that should be used for the runtime.
      */
-    constructor(version: AuxVersion, device: AuxDevice, libraryFactory?: (context: AuxGlobalContext) => AuxLibrary, editModeProvider?: AuxRealtimeEditModeProvider, forceSignedScripts?: boolean, exemptSpaces?: BotSpace[], forceSyncScripts?: boolean);
+    constructor(version: AuxVersion, device: AuxDevice, libraryFactory?: (context: AuxGlobalContext) => AuxLibrary, editModeProvider?: AuxRealtimeEditModeProvider, forceSignedScripts?: boolean, exemptSpaces?: BotSpace[], forceSyncScripts?: boolean, interpreter?: InterpreterType);
     getShoutTimers(): {
         [shout: string]: number;
     };
@@ -90,6 +105,10 @@ export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactor
      * An observable that resolves whenever the runtime issues an error.
      */
     get onErrors(): Observable<ScriptError[]>;
+    /**
+     * An observable that resolves whenever the runtime pauses in a script.
+     */
+    get onRuntimeStop(): Observable<RuntimeStop>;
     /**
      * Processes the given bot actions and dispatches the resulting actions in the future.
      * @param actions The actions to process.
@@ -101,6 +120,19 @@ export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactor
     private _processAction;
     private _registerPortalBot;
     private _rejectAction;
+    /**
+     * Executes the given function based on the current execution state of the runtime.
+     * If the runtime is stopped, then the given function will be executed after the current promise finishes.
+     * If the runtime is executing normally, then the given function will be executed immediately.
+     * Returns the function result if the function executes immediately,
+     * or returns a runtime promise if the function executes after the current promise.
+     *
+     * This function essentially forces the given function to execute synchronously with respect to other functions wrapped with this function.
+     *
+     * @param func The function to execute.
+     *
+     */
+    private _wrapWithCurrentPromise;
     /**
      * Executes a shout with the given event name on the given bot IDs with the given argument.
      * Also dispatches any actions and errors that occur.
@@ -108,17 +140,26 @@ export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactor
      * @param botIds The Bot IDs that the shout is being sent to.
      * @param arg The argument to include in the shout.
      */
-    shout(eventName: string, botIds?: string[], arg?: any): ActionResult;
+    shout(eventName: string, botIds?: string[], arg?: any): MaybeRuntimePromise<ActionResult>;
+    /**
+     * Executes the given shout synchronously with respect to other scripts that may be running or paused.
+     * @param eventName The name of the event that should be executed.
+     * @param botIds The IDs of the bots that the shout should be sent to.
+     * @param arg The argument that should be sent with the shout.
+     * @param batch Whether to batch events.
+     * @param resetEnergy Whether to reset the runtime energy before executing the shout.
+     */
+    private _synchronousShout;
     private _shout;
     /**
      * Executes the given script.
      * @param script The script to run.
      */
-    execute(script: string): {
+    execute(script: string): MaybeRuntimePromise<{
         result: any;
         actions: BotAction[];
         errors: ScriptError[];
-    };
+    }>;
     private _execute;
     /**
      * Signals to the runtime that the bots state has been updated.
@@ -179,5 +220,23 @@ export declare class AuxRuntime implements RuntimeBotInterface, RuntimeBotFactor
     private _mapBotsToRuntimeBots;
     private _mapBotsToRuntimeBotsCore;
     private _getFunctionNamesForBot;
+    setBreakpoint(breakpoint: RuntimeBreakpoint): void;
+    removeBreakpoint(breakpointId: string): void;
+    continueAfterStop(stopId: RuntimeStop['stopId'], continuation?: InterpreterContinuation): void;
+    private _scheduleJob;
+    private _scheduleJobQueueCheck;
+    private _processJobQueueNow;
+    processGenerator<T>(generator: Generator<InterpreterStop, T, InterpreterContinuation>): void;
+    private _processGenerator;
+    private _executeGenerator;
 }
+declare type MaybeRuntimePromise<T> = T | RuntimePromise<T>;
+/**
+ * Recursively maps each of the given library's functions using the given map function and returns a new library that contains the converted functions.
+ * The returned object will contain the same enumerable properties as the original library except that its functions have been mapped.
+ * @param library The library to map.
+ * @param map The function to use for mapping library functions.
+ */
+export declare function mapLibraryFunctions<T extends AuxLibrary>(library: T, map: (func: Function, key: string) => any): T;
+export {};
 //# sourceMappingURL=AuxRuntime.d.ts.map