@casual-simulation/js-interpreter 3.1.9-alpha.3340590989

package/Interpreter.d.ts

@@ -0,0 +1,218 @@
+import { Agent, ManagedRealm, Value, ObjectValue, SourceTextModuleRecord, Completion, ExecutionContextStack, ECMAScriptNode, ManagedSourceTextModuleRecord } from '@casual-simulation/engine262';
+export declare type PossibleBreakpointStates = ['before' | 'after'] | ['before', 'after'];
+/**
+ * Defines a class that wraps common engine262 capabilities.
+ */
+export declare class Interpreter {
+    private _valueSymbolMap;
+    private _realSymbolMap;
+    private _debugging;
+    private _breakpoints;
+    /**
+     * The agent that this interpreter is currently using.
+     */
+    agent: Agent;
+    /**
+     * The realm that this interpreter is using.
+     */
+    realm: ManagedRealm;
+    /**
+     * Gets whether this interpreter is currently debugging.
+     */
+    get debugging(): boolean;
+    /**
+     * Sets whether this interpreter is debugging.
+     */
+    set debugging(value: boolean);
+    /**
+     * Gets the list of breakpoints that have been set on this interpreter.
+     */
+    get breakpoints(): Breakpoint[];
+    constructor();
+    /**
+     * Creates a new ES6 module using the given code and name.
+     * @param moduleCode The code that the module is made up of.
+     * @param moduleId The ID of the module.
+     * @returns Returns the created module.
+     */
+    createAndLinkModule(moduleCode: string, moduleId: string): ManagedSourceTextModuleRecord;
+    /**
+     * Creates a new function in the global scope using the given function name, function code, and parameters names.
+     * @param functionName The name of the function.
+     * @param functionCode The code for the body of the function.
+     * @param paramNames The names of the parameters.
+     */
+    createFunction(functionName: string, functionCode: string, ...paramNames: string[]): ConstructedFunction;
+    /**
+     * Calls the given function
+     * @param func The function that should be called.
+     * @param args The arguments that should be provided to the function.
+     */
+    callFunction(func: ConstructedFunction, ...args: any[]): Generator<InterpreterStop, any, InterpreterContinuation>;
+    /**
+     * Runs the job queue and yields with any interpreter breaks that are encountered along the way.
+     */
+    runJobQueue(): Generator<InterpreterStop, void, InterpreterContinuation>;
+    private _handleBreakpoints;
+    /**
+     * Constructs a new interpreted object that proxies all of it's properties back to the given object.
+     * @param obj The object that should be proxied.
+     */
+    proxyObject(obj: Object): Completion<Value>;
+    /**
+     * Proxies the given interpreted value as a native JavaScript object.
+     * @param obj The interpreted object that should be proxied.
+     * @param allowBreakpointsInFunction Whether the object should yield breakpoints when it is called as a function or if it should execute normally. (Default true)
+     */
+    reverseProxyObject(obj: Value, allowBreakpointsInFunction?: boolean): any;
+    /**
+     * Sets the given breakpoint for execution.
+     * @param breakpoint The breakpoint that should be set.
+     */
+    setBreakpoint(breakpoint: Breakpoint): void;
+    /**
+     * Removes the breakpoint with the given ID.
+     * @param id The ID of the breakpoint that should be removed.
+     */
+    removeBreakpointById(id: string): void;
+    /**
+     * Lists the possible breakpoint locations for the given code.
+     * @param code The code.
+     */
+    listPossibleBreakpoints(code: ECMAScriptNode): PossibleBreakpointLocation[];
+    /**
+     * Copies the given value as a new interpreted object.
+     * @param value The value that should be copied.
+     */
+    copyToValue(value: any): Completion<Value>;
+    /**
+     * Copies the given value as a new regular JS object.
+     * @param value The value that should be copied.
+     * @param transformObject An optional function that can be used to transform objects.
+     */
+    copyFromValue(value: Value, transformObject?: (obj: Object) => void): any;
+    private _copyToObject;
+    private _copyFromObject;
+    private _getObjectInterpretedProto;
+    private _getObjectRealProto;
+    private _getInterpretedProxyConstructor;
+    private _getRealProxyConstructor;
+    private _getOrCreateSymbolFromReal;
+    private _getOrCreateSymbolFromValue;
+    /**
+     * Adds the given properties as properties of the global object.
+     * @param props The map of property names and values.
+     */
+    addGlobalProperties(props: Map<string, any | Value | Completion<Value>>): void;
+    private _setupGlobals;
+}
+export interface ConstructedFunction {
+    module: SourceTextModuleRecord;
+    func: ObjectValue;
+    name: string;
+}
+export declare type InterpreterContinuation = null | 'step-in' | 'step-out';
+export declare type InterpreterStop = InterpreterBeforeStop | InterpreterAfterStop;
+export interface InterpreterStopBase {
+    /**
+     * The node that the interpreter has stopped at.
+     */
+    node: any;
+    /**
+     * The breakpoint that triggered this stop.
+     */
+    breakpoint: Breakpoint;
+    /**
+     * The stack of execution contexts.
+     */
+    stack: ExecutionContextStack;
+}
+/**
+ * Defines an interface that contains information about the current stop state of the interpreter.
+ */
+export interface InterpreterBeforeStop extends InterpreterStopBase {
+    /**
+     * Whether this stop occurred before or after the node.
+     */
+    state: 'before';
+}
+/**
+ * Defines an interface that contains information about the current stop state of the interpreter.
+ */
+export interface InterpreterAfterStop extends InterpreterStopBase {
+    /**
+     * Whether this stop occurred before or after the node.
+     */
+    state: 'after';
+    /**
+     * The result of the expression/statement.
+     */
+    result: Completion<Value>;
+}
+/**
+ * Defines an interface for a possible breakpoint location.
+ */
+export interface PossibleBreakpointLocation {
+    /**
+     * The line number that the breakpoint stops at.
+     */
+    lineNumber: number;
+    /**
+     * The column number that the breakpoint stops at.
+     */
+    columnNumber: number;
+    /**
+     * The states that are reasonable for this breakpoint to stop at.
+     */
+    possibleStates: PossibleBreakpointStates;
+}
+/**
+ * Defines an interface for a breakpoint.
+ * That is, a spot where code execution should be paused.
+ */
+export interface Breakpoint {
+    /**
+     * The ID of the breakpoint.
+     */
+    id: string;
+    /**
+     * The function that the breakpoint applies to.
+     */
+    func: ConstructedFunction;
+    /**
+     * The line number that the breakpoint stops at.
+     */
+    lineNumber: number;
+    /**
+     * The column number that the breakpoint stops at.
+     */
+    columnNumber: number;
+    /**
+     * The list of states that the breakpoint applies for.
+     * - "before" indicates that the breakpoint stops before the node executes.
+     * - "after" indicates that the breakpoint stops after the node executes.
+     */
+    states: ('before' | 'after')[];
+    /**
+     * Whether the breakpoint is disabled.
+     * Defaults to false.
+     */
+    disabled?: boolean;
+}
+export interface BreakpointEntry {
+    breakpoint: Breakpoint;
+    location: ECMAScriptNode['location'];
+}
+/**
+ * Traverses over the given node.
+ * @param node The node.
+ */
+export declare function traverse(node: ECMAScriptNode): Generator<VisitedNode, void, VisitorOption>;
+export declare type VisitorOption = null | void | 'skip';
+export interface VisitedNode {
+    node: ECMAScriptNode;
+    parent: VisitedNode;
+    key: string;
+    depth: number;
+}
+//# sourceMappingURL=Interpreter.d.ts.map