narrat 2.0.7 → 2.0.9

package/dist/stores/main-store.d.ts

@@ -103,8 +103,8 @@ export declare const useMain: import("pinia").StoreDefinition<"main", MainState,
             reset(): void;
         }>;
         vm: import("pinia").Store<"vm", import("./vm-store").VMState, {
-            currentStack(state: {
-                lastChoiceCommand?: {
+            currentFrame(state: {
+                commandsWaitingForPlayerAnswer: {
                     args: (import("../types/parser").Parser.Primitive | {
                         code: string;
                         command: {
@@ -118,13 +118,14 @@ export declare const useMain: import("pinia").StoreDefinition<"main", MainState,
                         line: number;
                     })[];
                     commandType: string;
-                    options: import("../types/parser").Parser.DefaultArg;
+                    options: any;
                     code: string;
-                    staticOptions: {};
+                    staticOptions: any;
                     operator: string;
                     line: number;
                     fileName: string;
-                } | undefined;
+                    finishCommand?: ((res: any) => void) | undefined;
+                }[];
                 stack: {
                     currentIndex: number;
                     branchData: {
@@ -155,36 +156,37 @@ export declare const useMain: import("pinia").StoreDefinition<"main", MainState,
                 currentScope: {
                     [key: string]: any;
                 };
-            } & import("pinia").PiniaCustomStateProperties<import("./vm-store").VMState>): {
-                currentIndex: number;
-                branchData: {
-                    branch: {
-                        code: string;
-                        command: {
-                            commandType: string;
-                            operator: string;
-                            args: (import("../types/parser").Parser.Primitive | any)[];
-                            options: import("../types/parser").Parser.DefaultArg;
-                            staticOptions: {};
-                        };
-                        fileName: string;
-                        line: number;
-                    }[];
-                    args?: string[] | undefined;
-                };
-                label: string;
-                scope: {
-                    [key: string]: any;
-                };
-                onComplete?: ((result: any) => void) | undefined;
-                returnValue: any;
-            };
+            } & import("pinia").PiniaCustomStateProperties<import("./vm-store").VMState>): import("./vm-store").MachineFrame | undefined;
             currentLine(): import("../types/parser").Parser.ParsedExpression<import("../types/parser").Parser.DefaultArg, {}> | undefined;
+            commandWaitingForAnswer(): import("../types/parser").Parser.Command<any, any> | undefined;
         }, {
             generateSaveData(): import("./vm-store").VMSave;
             loadSaveData(data: import("./vm-store").VMSave): void;
             resetScope(): void;
             setReturnValue(value: any): void;
+            waitForPlayerAnswer(cmd: import("../types/parser").Parser.Command<any, any>): void;
+            popAnswerQueue(): {
+                args: (import("../types/parser").Parser.Primitive | {
+                    code: string;
+                    command: {
+                        commandType: string;
+                        operator: string;
+                        args: (import("../types/parser").Parser.Primitive | any)[];
+                        options: import("../types/parser").Parser.DefaultArg;
+                        staticOptions: {};
+                    };
+                    fileName: string;
+                    line: number;
+                })[];
+                commandType: string;
+                options: any;
+                code: string;
+                staticOptions: any;
+                operator: string;
+                line: number;
+                fileName: string;
+                finishCommand?: ((res: any) => void) | undefined;
+            } | undefined;
             removeFromScope(vars: string[]): void;
             addScopedVariable(key: string, value: any): void;
             extendScope(scope: {
@@ -197,16 +199,21 @@ export declare const useMain: import("pinia").StoreDefinition<"main", MainState,
             setScript(script: import("../types/parser").Parser.ParsedScript): void;
             overrideData(data: import("./vm-store").DataState): void;
             setStack(stack: import("./vm-store").SetStackOptions): void;
-            stackOptionsToStack(stack: import("./vm-store").SetStackOptions): import("./vm-store").MachineStack;
+            stackOptionsToStack(stack: import("./vm-store").SetStackOptions): import("./vm-store").MachineFrame;
             setData(path: string, value: any): void;
             addInstruction(path: string, value: any): void;
-            addStack(newStackOptions: import("./vm-store").AddStackOptions): Promise<void>;
+            addFrame(newStackOptions: import("./vm-store").AddFrameOptions): void;
+            addAndRunFrame(newStackOptions: import("./vm-store").AddFrameOptions): Promise<void>;
+            runFrame(): Promise<void>;
+            runGame(): Promise<void>;
+            nextLineOnly(): Promise<boolean>;
             nextLine(): Promise<any>;
-            previousStack(): Promise<any>;
-            finishGame(): void;
+            previousFrame(): Promise<any>;
+            reachedEndOfScript(): void;
+            runLineOnly(): Promise<void>;
             runLine(): Promise<void>;
             runLabelFunction(label: string, ...args: any[]): Promise<unknown>;
-            runCustomStack(stack: import("./vm-store").AddStackOptions): void;
+            runCustomFrame(stack: import("./vm-store").AddFrameOptions): void;
             runLabel(label: string, ...args: any[]): void;
         }>;
         hud: import("pinia").Store<"hud", import("./hud-stats-store").HudState, {}, {

package/dist/stores/vm-store.d.ts

@@ -1,8 +1,8 @@
 import { Parser } from '../types/parser';
-export declare type AddStackOptions = Omit<SetStackOptions, 'label'> & {
+export declare type AddFrameOptions = Omit<SetStackOptions, 'label'> & {
     label?: string;
 };
-export interface MachineStack {
+export interface MachineFrame {
     currentIndex: number;
     branchData: Parser.ParsedLabel;
     label: string;
@@ -26,8 +26,8 @@ export interface DataState {
     [key: string]: any;
 }
 export interface VMState {
-    lastChoiceCommand?: Parser.Command;
-    stack: MachineStack[];
+    commandsWaitingForPlayerAnswer: Parser.Command<any, any>[];
+    stack: MachineFrame[];
     script: Parser.ParsedScript;
     data: DataState;
     lastLabel: string;
@@ -40,8 +40,8 @@ export interface VMSave {
     data: DataState;
 }
 export declare const useVM: import("pinia").StoreDefinition<"vm", VMState, {
-    currentStack(state: {
-        lastChoiceCommand?: {
+    currentFrame(state: {
+        commandsWaitingForPlayerAnswer: {
             args: (Parser.Primitive | {
                 code: string;
                 command: {
@@ -55,13 +55,14 @@ export declare const useVM: import("pinia").StoreDefinition<"vm", VMState, {
                 line: number;
             })[];
             commandType: string;
-            options: Parser.DefaultArg;
+            options: any;
             code: string;
-            staticOptions: {};
+            staticOptions: any;
             operator: string;
             line: number;
             fileName: string;
-        } | undefined;
+            finishCommand?: ((res: any) => void) | undefined;
+        }[];
         stack: {
             currentIndex: number;
             branchData: {
@@ -92,36 +93,37 @@ export declare const useVM: import("pinia").StoreDefinition<"vm", VMState, {
         currentScope: {
             [key: string]: any;
         };
-    } & import("pinia").PiniaCustomStateProperties<VMState>): {
-        currentIndex: number;
-        branchData: {
-            branch: {
-                code: string;
-                command: {
-                    commandType: string;
-                    operator: string;
-                    args: (Parser.Primitive | any)[];
-                    options: Parser.DefaultArg;
-                    staticOptions: {};
-                };
-                fileName: string;
-                line: number;
-            }[];
-            args?: string[] | undefined;
-        };
-        label: string;
-        scope: {
-            [key: string]: any;
-        };
-        onComplete?: ((result: any) => void) | undefined;
-        returnValue: any;
-    };
+    } & import("pinia").PiniaCustomStateProperties<VMState>): MachineFrame | undefined;
     currentLine(): Parser.ParsedExpression<Parser.DefaultArg, {}> | undefined;
+    commandWaitingForAnswer(): Parser.Command<any, any> | undefined;
 }, {
     generateSaveData(): VMSave;
     loadSaveData(data: VMSave): void;
     resetScope(): void;
     setReturnValue(value: any): void;
+    waitForPlayerAnswer(cmd: Parser.Command<any, any>): void;
+    popAnswerQueue(): {
+        args: (Parser.Primitive | {
+            code: string;
+            command: {
+                commandType: string;
+                operator: string;
+                args: (Parser.Primitive | any)[];
+                options: Parser.DefaultArg;
+                staticOptions: {};
+            };
+            fileName: string;
+            line: number;
+        })[];
+        commandType: string;
+        options: any;
+        code: string;
+        staticOptions: any;
+        operator: string;
+        line: number;
+        fileName: string;
+        finishCommand?: ((res: any) => void) | undefined;
+    } | undefined;
     removeFromScope(vars: string[]): void;
     addScopedVariable(key: string, value: any): void;
     extendScope(scope: {
@@ -134,15 +136,20 @@ export declare const useVM: import("pinia").StoreDefinition<"vm", VMState, {
     setScript(script: Parser.ParsedScript): void;
     overrideData(data: DataState): void;
     setStack(stack: SetStackOptions): void;
-    stackOptionsToStack(stack: SetStackOptions): MachineStack;
+    stackOptionsToStack(stack: SetStackOptions): MachineFrame;
     setData(path: string, value: any): void;
     addInstruction(path: string, value: any): void;
-    addStack(newStackOptions: AddStackOptions): Promise<void>;
+    addFrame(newStackOptions: AddFrameOptions): void;
+    addAndRunFrame(newStackOptions: AddFrameOptions): Promise<void>;
+    runFrame(): Promise<void>;
+    runGame(): Promise<void>;
+    nextLineOnly(): Promise<boolean>;
     nextLine(): Promise<any>;
-    previousStack(): Promise<any>;
-    finishGame(): void;
+    previousFrame(): Promise<any>;
+    reachedEndOfScript(): void;
+    runLineOnly(): Promise<void>;
     runLine(): Promise<void>;
     runLabelFunction(label: string, ...args: any[]): Promise<unknown>;
-    runCustomStack(stack: AddStackOptions): void;
+    runCustomFrame(stack: AddFrameOptions): void;
     runLabel(label: string, ...args: any[]): void;
 }>;

package/dist/types/parser.d.ts

@@ -60,6 +60,7 @@ export declare namespace Parser {
         operator: string;
         line: number;
         fileName: string;
+        finishCommand?: (res: any) => void;
     }
     type Arg = ParsedExpression | Primitive;
     interface ParsedExpression<Options = CommandOptions, StaticOptions = {}> {

package/dist/vm/commands/command-plugin.d.ts

@@ -13,13 +13,26 @@ export interface CommandParsingContext {
     lines: Parser.Line[];
     currentLine: number;
 }
+export declare type OnPlayerAnswered<Options, StaticOptions> = (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<any>;
+export interface CommandPluginOptions<Options, StaticOptions = {}> {
+    keyword: string;
+    argTypes: ArgTypes;
+    runner: CommandRunner<Options, StaticOptions>;
+    parser?: CommandParserFunction<Options, StaticOptions>;
+    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
+    returnAfterPlayerAnswer?: boolean;
+}
 export declare class CommandPlugin<Options, StaticOptions = {}> {
     keyword: string;
     runner: CommandRunner<Options, StaticOptions>;
     argTypes: ArgTypes;
     parser: CommandParserFunction<Options, StaticOptions>;
-    onPlayerAnswered?: (cmd: Parser.Command<Options, StaticOptions>, choice: number | string) => Promise<void>;
+    onPlayerAnswered?: OnPlayerAnswered<Options, StaticOptions>;
+    returnAfterPlayerAnswer: boolean;
     constructor(keyword: string, argTypes: ArgTypes, runner: CommandRunner<Options, StaticOptions>, parser?: CommandParserFunction<Options, StaticOptions>);
+    run(cmd: Parser.Command<Options, StaticOptions>, choices?: DialogChoice[]): Promise<any>;
+    processPlayerAnswer(cmd: Parser.Command<Options, StaticOptions>, choice: number | string): Promise<any>;
+    static FromOptions<Options, StaticOptions = {}>(options: CommandPluginOptions<Options, StaticOptions>): CommandPlugin<Options, StaticOptions>;
 }
 export declare type ArgTypes = ArgumentDescription[] | 'any';
 export interface ArgumentDescription {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "narrat",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "narrat narrative engine",
   "main": "dist/narrat.umd.js",
   "module": "dist/narrat.es.js",