narraleaf-react 0.5.0 → 0.6.0

package/dist/game/nlcore/action/actions/displayableAction.d.ts

@@ -1,22 +1,26 @@
-import { DisplayableActionContentType, DisplayableActionTypes } from "../../action/actionTypes";
-import { GameState } from "../../../player/gameState";
-import { TypedAction } from "../../action/actions";
-import { Awaitable, Values } from "../../../../util/data";
-import { Displayable } from "../../elements/displayable/displayable";
-import type { CalledActionResult } from "../../gameTypes";
-import { Scene } from "../../elements/scene";
-import { Transform } from "../../elements/transform/transform";
-import { Transition } from "../../elements/transition/transition";
-import { Layer } from "../../elements/layer";
-export declare class DisplayableAction<T extends Values<typeof DisplayableActionTypes> = Values<typeof DisplayableActionTypes>, Self extends Displayable<any, any, any> = Displayable<any, any>, TransitionType extends Transition = Transition> extends TypedAction<DisplayableActionContentType<TransitionType>, T, Self> {
-    static ActionTypes: {
-        readonly action: "displayable:action";
-        readonly applyTransform: "displayable:applyTransform";
-        readonly applyTransition: "displayable:applyTransition";
-        readonly init: "displayable:init";
-    };
-    executeAction(gameState: GameState): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
-    applyTransform(state: GameState, element: Displayable<any, any>, transform: Transform, onFinished?: () => void): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
-    applyTransition(state: GameState, element: Displayable<any, any>, transition: TransitionType, onFinished?: () => void): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
-    initDisplayable(state: GameState, scene: Scene | null, element: Displayable<any, any>, layer: Layer | null, isElement?: boolean | undefined): Awaitable<CalledActionResult>;
-}
+import { DisplayableActionContentType, DisplayableActionTypes } from "../../action/actionTypes";
+import { GameState } from "../../../player/gameState";
+import { TypedAction } from "../../action/actions";
+import { Awaitable, Values } from "../../../../util/data";
+import { Displayable } from "../../elements/displayable/displayable";
+import type { CalledActionResult } from "../../gameTypes";
+import { Scene } from "../../elements/scene";
+import { Transform } from "../../elements/transform/transform";
+import { Transition } from "../../elements/transition/transition";
+import { Layer } from "../../elements/layer";
+import { LogicAction } from "../../action/logicAction";
+import { ActionExecutionInjection, ExecutedActionResult } from "../../action/action";
+import { Story } from "../../elements/story";
+export declare class DisplayableAction<T extends Values<typeof DisplayableActionTypes> = Values<typeof DisplayableActionTypes>, Self extends Displayable<any, any, any> = Displayable<any, any>, TransitionType extends Transition = Transition> extends TypedAction<DisplayableActionContentType<TransitionType>, T, Self> {
+    static ActionTypes: {
+        readonly action: "displayable:action";
+        readonly applyTransform: "displayable:applyTransform";
+        readonly applyTransition: "displayable:applyTransition";
+        readonly init: "displayable:init";
+    };
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
+    applyTransform(state: GameState, element: Displayable<any, any>, transform: Transform, injection: ActionExecutionInjection, onFinished?: () => void): Awaitable<CalledActionResult, CalledActionResult>;
+    applyTransition(state: GameState, element: Displayable<any, any>, transition: TransitionType, injection: ActionExecutionInjection, onFinished?: () => void): Awaitable<CalledActionResult, CalledActionResult>;
+    initDisplayable(state: GameState, scene: Scene | null, element: Displayable<any, any>, layer: Layer | null, isElement: boolean | undefined, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/imageAction.d.ts

@@ -1,23 +1,25 @@
-import { ImageActionContentType, ImageActionTypes } from "../../action/actionTypes";
-import { Image } from "../../elements/displayable/image";
-import { GameState } from "../../../player/gameState";
-import type { CalledActionResult } from "../../gameTypes";
-import { Awaitable } from "../../../../util/data";
-import { ContentNode } from "../../action/tree/actionTree";
-import { TypedAction } from "../../action/actions";
-import { Color } from "../../types";
-export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof ImageActionTypes] = typeof ImageActionTypes[keyof typeof ImageActionTypes]> extends TypedAction<ImageActionContentType, T, Image> {
-    static ActionTypes: {
-        readonly action: "image:action";
-        readonly setSrc: "image:setSrc";
-        readonly flush: "image:flush";
-        readonly initWearable: "image:initWearable";
-        readonly setAppearance: "image:setAppearance";
-        readonly setDarkness: "image:setDarkness";
-    };
-    static resolveTagSrc(image: Image, tags: string[]): string;
-    static resolveCurrentSrc(image: Image): string | Color;
-    type: T;
-    contentNode: ContentNode<ImageActionContentType[T]>;
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
+import { ImageActionContentType, ImageActionTypes } from "../../action/actionTypes";
+import { Image } from "../../elements/displayable/image";
+import { GameState } from "../../../player/gameState";
+import { ContentNode } from "../../action/tree/actionTree";
+import { TypedAction } from "../../action/actions";
+import { Color } from "../../types";
+import { ActionExecutionInjection, ExecutedActionResult } from "../../action/action";
+import { LogicAction } from "../../action/logicAction";
+import { Story } from "../../elements/story";
+export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof ImageActionTypes] = typeof ImageActionTypes[keyof typeof ImageActionTypes]> extends TypedAction<ImageActionContentType, T, Image> {
+    static ActionTypes: {
+        readonly action: "image:action";
+        readonly setSrc: "image:setSrc";
+        readonly flush: "image:flush";
+        readonly initWearable: "image:initWearable";
+        readonly setAppearance: "image:setAppearance";
+        readonly setDarkness: "image:setDarkness";
+    };
+    static resolveTagSrc(image: Image, tags: string[]): string;
+    static resolveCurrentSrc(image: Image): string | Color;
+    type: T;
+    contentNode: ContentNode<ImageActionContentType[T]>;
+    executeAction(state: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/layerAction.d.ts

@@ -1,13 +1,16 @@
-import { LayerActionContentType, LayerActionTypes } from "../../action/actionTypes";
-import { TypedAction } from "../../action/actions";
-import { GameState } from "../../../player/gameState";
-import { CalledActionResult } from "../../gameTypes";
-import { Awaitable, Values } from "../../../../util/data";
-import { Layer } from "../../elements/layer";
-export declare class LayerAction<T extends Values<typeof LayerActionTypes> = Values<typeof LayerActionTypes>> extends TypedAction<LayerActionContentType, T, Layer> {
-    static ActionTypes: {
-        readonly action: "layer:action";
-        readonly setZIndex: "layer:setZIndex";
-    };
-    executeAction(gameState: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
+import { LayerActionContentType, LayerActionTypes } from "../../action/actionTypes";
+import { TypedAction } from "../../action/actions";
+import { Layer } from "../../elements/layer";
+import { Values } from "../../../../util/data";
+import { GameState } from "../../../player/gameState";
+import { ActionExecutionInjection, ExecutedActionResult } from "../../action/action";
+import { LogicAction } from "../../action/logicAction";
+import { Story } from "../../elements/story";
+export declare class LayerAction<T extends Values<typeof LayerActionTypes> = Values<typeof LayerActionTypes>> extends TypedAction<LayerActionContentType, T, Layer> {
+    static ActionTypes: {
+        readonly action: "layer:action";
+        readonly setZIndex: "layer:setZIndex";
+    };
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/menuAction.d.ts

@@ -1,16 +1,21 @@
-import { MenuActionContentType, MenuActionTypes } from "../../action/actionTypes";
-import type { Menu } from "../../elements/menu";
-import { GameState } from "../../../player/gameState";
-import { Awaitable } from "../../../../util/data";
-import type { CalledActionResult } from "../../gameTypes";
-import { TypedAction } from "../../action/actions";
-import { Story } from "../../elements/story";
-import { LogicAction } from "../../action/logicAction";
-import { ActionSearchOptions } from "../../types";
-export declare class MenuAction<T extends typeof MenuActionTypes[keyof typeof MenuActionTypes] = typeof MenuActionTypes[keyof typeof MenuActionTypes]> extends TypedAction<MenuActionContentType, T, Menu> {
-    static ActionTypes: {
-        readonly action: "menu:action";
-    };
-    executeAction(state: GameState): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
-    getFutureActions(story: Story, options: ActionSearchOptions): LogicAction.Actions[];
-}
+import { MenuActionContentType, MenuActionTypes } from "../../action/actionTypes";
+import type { Menu } from "../../elements/menu";
+import { GameState } from "../../../player/gameState";
+import { Awaitable } from "../../../../util/data";
+import type { CalledActionResult } from "../../gameTypes";
+import { TypedAction } from "../../action/actions";
+import { Story } from "../../elements/story";
+import { LogicAction } from "../../action/logicAction";
+import { ActionSearchOptions } from "../../types";
+import { ActionExecutionInjection } from "../../action/action";
+export declare class MenuAction<T extends typeof MenuActionTypes[keyof typeof MenuActionTypes] = typeof MenuActionTypes[keyof typeof MenuActionTypes]> extends TypedAction<MenuActionContentType, T, Menu> {
+    static ActionTypes: {
+        readonly action: "menu:action";
+    };
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): (Awaitable<CalledActionResult, CalledActionResult> | {
+        type: T;
+        node: import("../../action/tree/actionTree").RenderableNode | null;
+    })[];
+    getFutureActions(story: Story, options: ActionSearchOptions): LogicAction.Actions[];
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/persistentAction.d.ts

@@ -1,13 +1,17 @@
-import { PersistentActionContentType, PersistentActionTypes } from "../../action/actionTypes";
-import { GameState } from "../../../player/gameState";
-import { TypedAction } from "../../action/actions";
-import { Values } from "../../../../util/data";
-import { Persistent } from "../../elements/persistent";
-export declare class PersistentAction<T extends Values<typeof PersistentActionTypes> = Values<typeof PersistentActionTypes>> extends TypedAction<PersistentActionContentType, T, Persistent<any>> {
-    static ActionTypes: {
-        readonly action: "persistent:action";
-        readonly set: "persistent:set";
-        readonly assign: "persistent:assign";
-    };
-    executeAction(gameState: GameState): import("../../gameTypes").CalledActionResult<any> | import("../../../../util/data").Awaitable<import("../../gameTypes").CalledActionResult<any>, any>;
-}
+import { PersistentActionContentType, PersistentActionTypes } from "../../action/actionTypes";
+import { GameState } from "../../../player/gameState";
+import { TypedAction } from "../../action/actions";
+import { Values } from "../../../../util/data";
+import { Persistent } from "../../elements/persistent";
+import { ActionExecutionInjection } from "../../action/action";
+import { LogicAction } from "../../action/logicAction";
+import { Story } from "../../elements/story";
+export declare class PersistentAction<T extends Values<typeof PersistentActionTypes> = Values<typeof PersistentActionTypes>> extends TypedAction<PersistentActionContentType, T, Persistent<any>> {
+    static ActionTypes: {
+        readonly action: "persistent:action";
+        readonly set: "persistent:set";
+        readonly assign: "persistent:assign";
+    };
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): import("../../action/action").ExecutedActionResult;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/sceneAction.d.ts

@@ -1,44 +1,47 @@
-import { SceneActionContentType, SceneActionTypes } from "../../action/actionTypes";
-import type { Scene, SceneDataRaw } from "../../elements/scene";
-import { GameState, PlayerStateElementSnapshot } from "../../../player/gameState";
-import { Awaitable } from "../../../../util/data";
-import type { CalledActionResult } from "../../gameTypes";
-import { ContentNode } from "../../action/tree/actionTree";
-import { LogicAction } from "../../action/logicAction";
-import { TypedAction } from "../../action/actions";
-import { Story } from "../../elements/story";
-import { ImageTransition } from "../../elements/transition/transitions/image/imageTransition";
-import { ActionSearchOptions } from "../../types";
-import { ExposedState, ExposedStateType } from "../../../player/type";
-import { ImageDataRaw } from "../../elements/displayable/image";
-type SceneSnapshot = {
-    state: SceneDataRaw | null;
-    local: Record<string, any>;
-    element: PlayerStateElementSnapshot;
-    background: ImageDataRaw | null;
-};
-export declare class SceneAction<T extends typeof SceneActionTypes[keyof typeof SceneActionTypes] = typeof SceneActionTypes[keyof typeof SceneActionTypes]> extends TypedAction<SceneActionContentType, T, Scene> {
-    static ActionTypes: {
-        readonly action: "scene:action";
-        readonly init: "scene:init";
-        readonly exit: "scene:exit";
-        readonly jumpTo: "scene:jumpTo";
-        readonly setBackgroundMusic: "scene:setBackgroundMusic";
-        readonly preUnmount: "scene:preUnmount";
-        readonly transitionToScene: "scene:transitionToScene";
-    };
-    static handleSceneInit(scene: Scene, next: CalledActionResult, state: GameState, awaitable: Awaitable<CalledActionResult, any>): {
-        type: any;
-        node: ContentNode<any> | null;
-    } | Awaitable<CalledActionResult<any>, any>;
-    static initBackgroundMusic(scene: Scene, exposed: ExposedState[ExposedStateType.scene]): void;
-    static createSceneSnapshot(scene: Scene, state: GameState): SceneSnapshot;
-    static restoreSceneSnapshot(snapshot: SceneSnapshot, state: GameState): void;
-    applyTransition(gameState: GameState, transition: ImageTransition): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
-    exit(state: GameState): void;
-    executeAction(gameState: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-    getFutureActions(story: Story, searchOptions?: ActionSearchOptions): LogicAction.Actions[];
-    _sceneNotFoundError(sceneId: string): Error;
-    getSceneName(scene: Scene | string): string;
-}
-export {};
+import { SceneActionContentType, SceneActionTypes } from "../../action/actionTypes";
+import type { Scene, SceneDataRaw } from "../../elements/scene";
+import { GameState, PlayerStateElementSnapshot } from "../../../player/gameState";
+import { Awaitable } from "../../../../util/data";
+import type { CalledActionResult } from "../../gameTypes";
+import { ContentNode } from "../../action/tree/actionTree";
+import { LogicAction } from "../../action/logicAction";
+import { TypedAction } from "../../action/actions";
+import { Story } from "../../elements/story";
+import { ImageTransition } from "../../elements/transition/transitions/image/imageTransition";
+import { ActionSearchOptions } from "../../types";
+import { ExposedState, ExposedStateType } from "../../../player/type";
+import { ImageDataRaw } from "../../elements/displayable/image";
+import { ActionExecutionInjection, ExecutedActionResult } from "../action";
+type SceneSnapshot = {
+    state: SceneDataRaw | null;
+    local: Record<string, any>;
+    element: PlayerStateElementSnapshot;
+    background: ImageDataRaw | null;
+};
+export declare class SceneAction<T extends typeof SceneActionTypes[keyof typeof SceneActionTypes] = typeof SceneActionTypes[keyof typeof SceneActionTypes]> extends TypedAction<SceneActionContentType, T, Scene> {
+    static ActionTypes: {
+        readonly action: "scene:action";
+        readonly init: "scene:init";
+        readonly exit: "scene:exit";
+        readonly jumpTo: "scene:jumpTo";
+        readonly setBackgroundMusic: "scene:setBackgroundMusic";
+        readonly preUnmount: "scene:preUnmount";
+        readonly transitionToScene: "scene:transitionToScene";
+    };
+    static handleSceneInit(scene: Scene, next: CalledActionResult, state: GameState, awaitable: Awaitable<CalledActionResult, any>): {
+        type: any;
+        node: ContentNode<any> | null;
+        wait?: import("../../gameTypes").StackModelWaiting | null;
+    } | Awaitable<CalledActionResult, any>;
+    static initBackgroundMusic(scene: Scene, exposed: ExposedState[ExposedStateType.scene]): void;
+    static createSceneSnapshot(scene: Scene, state: GameState): SceneSnapshot;
+    static restoreSceneSnapshot(snapshot: SceneSnapshot, state: GameState): void;
+    applyTransition(gameState: GameState, transition: ImageTransition, injection: ActionExecutionInjection): Awaitable<CalledActionResult, CalledActionResult>;
+    exit(state: GameState): void;
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
+    getFutureActions(story: Story, searchOptions?: ActionSearchOptions): LogicAction.Actions[];
+    _sceneNotFoundError(sceneId: string): Error;
+    getSceneName(scene: Scene | string): string;
+    stringify(story: Story, seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}
+export {};

package/dist/game/nlcore/action/actions/scriptAction.d.ts

@@ -1,10 +1,14 @@
-import { ScriptActionContentType, ScriptActionTypes } from "../../action/actionTypes";
-import type { Script } from "../../elements/script";
-import { GameState } from "../../../player/gameState";
-import { TypedAction } from "../../action/actions";
-export declare class ScriptAction<T extends typeof ScriptActionTypes[keyof typeof ScriptActionTypes] = typeof ScriptActionTypes[keyof typeof ScriptActionTypes]> extends TypedAction<ScriptActionContentType, T, Script> {
-    static ActionTypes: {
-        readonly action: "script:action";
-    };
-    executeAction(gameState: GameState): import("../../gameTypes").CalledActionResult<any> | import("../../../../util/data").Awaitable<import("../../gameTypes").CalledActionResult<any>, any>;
-}
+import { ScriptActionContentType, ScriptActionTypes } from "../../action/actionTypes";
+import type { Script } from "../../elements/script";
+import { GameState } from "../../../player/gameState";
+import { TypedAction } from "../../action/actions";
+import { ActionExecutionInjection } from "../action";
+import { Story } from "../../elements/story";
+import { LogicAction } from "../../action/logicAction";
+export declare class ScriptAction<T extends typeof ScriptActionTypes[keyof typeof ScriptActionTypes] = typeof ScriptActionTypes[keyof typeof ScriptActionTypes]> extends TypedAction<ScriptActionContentType, T, Script> {
+    static ActionTypes: {
+        readonly action: "script:action";
+    };
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): import("../action").ExecutedActionResult;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/soundAction.d.ts

@@ -1,18 +1,20 @@
-import { SoundActionContentType, SoundActionTypes } from "../../action/actionTypes";
-import type { Sound } from "../../elements/sound";
-import { GameState } from "../../../player/gameState";
-import type { CalledActionResult } from "../../gameTypes";
-import { Awaitable } from "../../../../util/data";
-import { TypedAction } from "../../action/actions";
-export declare class SoundAction<T extends typeof SoundActionTypes[keyof typeof SoundActionTypes] = typeof SoundActionTypes[keyof typeof SoundActionTypes]> extends TypedAction<SoundActionContentType, T, Sound> {
-    static ActionTypes: {
-        readonly action: "sound:action";
-        readonly play: "sound:play";
-        readonly stop: "sound:stop";
-        readonly setVolume: "sound:setVolume";
-        readonly setRate: "sound:setRate";
-        readonly pause: "sound:pause";
-        readonly resume: "sound:resume";
-    };
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
+import { TypedAction } from "../../action/actions";
+import { SoundActionContentType, SoundActionTypes } from "../../action/actionTypes";
+import type { Sound } from "../../elements/sound";
+import { GameState } from "../../../player/gameState";
+import { ActionExecutionInjection, ExecutedActionResult } from "../../action/action";
+import { LogicAction } from "../../action/logicAction";
+import { Story } from "../../elements/story";
+export declare class SoundAction<T extends typeof SoundActionTypes[keyof typeof SoundActionTypes] = typeof SoundActionTypes[keyof typeof SoundActionTypes]> extends TypedAction<SoundActionContentType, T, Sound> {
+    static ActionTypes: {
+        readonly action: "sound:action";
+        readonly play: "sound:play";
+        readonly stop: "sound:stop";
+        readonly setVolume: "sound:setVolume";
+        readonly setRate: "sound:setRate";
+        readonly pause: "sound:pause";
+        readonly resume: "sound:resume";
+    };
+    executeAction(state: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/storyAction.d.ts

@@ -1,8 +1,8 @@
-import { StoryActionContentType, StoryActionTypes } from "../../action/actionTypes";
-import type { Story } from "../../elements/story";
-import { TypedAction } from "../../action/actions";
-export declare class StoryAction<T extends typeof StoryActionTypes[keyof typeof StoryActionTypes] = typeof StoryActionTypes[keyof typeof StoryActionTypes]> extends TypedAction<StoryActionContentType, T, Story> {
-    static ActionTypes: {
-        readonly action: "story:action";
-    };
-}
+import { StoryActionContentType, StoryActionTypes } from "../../action/actionTypes";
+import type { Story } from "../../elements/story";
+import { TypedAction } from "../../action/actions";
+export declare class StoryAction<T extends typeof StoryActionTypes[keyof typeof StoryActionTypes] = typeof StoryActionTypes[keyof typeof StoryActionTypes]> extends TypedAction<StoryActionContentType, T, Story> {
+    static ActionTypes: {
+        readonly action: "story:action";
+    };
+}

package/dist/game/nlcore/action/actions/textAction.d.ts

@@ -1,14 +1,16 @@
-import { TextActionContentType, TextActionTypes } from "../../action/actionTypes";
-import { TypedAction } from "../../action/actions";
-import { GameState } from "../../../player/gameState";
-import { CalledActionResult } from "../../gameTypes";
-import { Awaitable } from "../../../../util/data";
-import { Text } from "../../elements/displayable/text";
-export declare class TextAction<T extends typeof TextActionTypes[keyof typeof TextActionTypes] = typeof TextActionTypes[keyof typeof TextActionTypes]> extends TypedAction<TextActionContentType, T, Text> {
-    static ActionTypes: {
-        readonly action: "text:action";
-        readonly setText: "text:setText";
-        readonly setFontSize: "text:setFontSize";
-    };
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
+import { TextActionContentType, TextActionTypes } from "../../action/actionTypes";
+import { TypedAction } from "../../action/actions";
+import { Text } from "../../elements/displayable/text";
+import { GameState } from "../../../player/gameState";
+import { ActionExecutionInjection, ExecutedActionResult } from "../../action/action";
+import { LogicAction } from "../../action/logicAction";
+import { Story } from "../../elements/story";
+export declare class TextAction<T extends typeof TextActionTypes[keyof typeof TextActionTypes] = typeof TextActionTypes[keyof typeof TextActionTypes]> extends TypedAction<TextActionContentType, T, Text> {
+    static ActionTypes: {
+        readonly action: "text:action";
+        readonly setText: "text:setText";
+        readonly setFontSize: "text:setFontSize";
+    };
+    executeAction(state: GameState, injection: ActionExecutionInjection): ExecutedActionResult;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions/videoAction.d.ts

@@ -1,22 +1,26 @@
-import { VideoActionContentType, VideoActionTypes } from "../../action/actionTypes";
-import { TypedAction } from "../../action/actions";
-import { Video } from "../../elements/video";
-import { GameState } from "../../../player/gameState";
-import { Awaitable, Values } from "../../../../util/data";
-import type { CalledActionResult } from "../../gameTypes";
-export declare class VideoAction<T extends Values<typeof VideoActionTypes> = Values<typeof VideoActionTypes>> extends TypedAction<VideoActionContentType, T, Video> {
-    static ActionTypes: {
-        readonly action: "video:action";
-        readonly show: "video:show";
-        readonly hide: "video:hide";
-        readonly play: "video:play";
-        readonly pause: "video:pause";
-        readonly resume: "video:resume";
-        readonly stop: "video:stop";
-        readonly seek: "video:seek";
-    };
-    executeAction(gameState: GameState): Awaitable<CalledActionResult>;
-    private changeStateBase;
-    private changeState;
-    private changeStateAsync;
-}
+import { VideoActionContentType, VideoActionTypes } from "../../action/actionTypes";
+import { TypedAction } from "../../action/actions";
+import { Video } from "../../elements/video";
+import { GameState } from "../../../player/gameState";
+import { Awaitable, Values } from "../../../../util/data";
+import type { CalledActionResult } from "../../gameTypes";
+import { ActionExecutionInjection } from "../../action/action";
+import { LogicAction } from "../../action/logicAction";
+import { Story } from "../../elements/story";
+export declare class VideoAction<T extends Values<typeof VideoActionTypes> = Values<typeof VideoActionTypes>> extends TypedAction<VideoActionContentType, T, Video> {
+    static ActionTypes: {
+        readonly action: "video:action";
+        readonly show: "video:show";
+        readonly hide: "video:hide";
+        readonly play: "video:play";
+        readonly pause: "video:pause";
+        readonly resume: "video:resume";
+        readonly stop: "video:stop";
+        readonly seek: "video:seek";
+    };
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
+    private changeStateBase;
+    private changeState;
+    private changeStateAsync;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

package/dist/game/nlcore/action/actions.d.ts

@@ -1,13 +1,20 @@
-import { ContentNode } from "../action/tree/actionTree";
-import { LogicAction } from "../action/logicAction";
-import { Action } from "../action/action";
-import { Chained, Proxied } from "../action/chain";
-import { Awaitable } from "../../../util/data";
-import { CalledActionResult } from "../gameTypes";
-export declare class TypedAction<ContentType extends Record<string, any> = Record<string, any>, T extends keyof ContentType & string = keyof ContentType & string, Callee extends LogicAction.GameElement = LogicAction.GameElement> extends Action<ContentType[T], Callee, T> {
-    callee: Callee;
-    constructor(callee: Proxied<Callee, Chained<LogicAction.Actions, Callee>>, type: T, contentNode: ContentNode<ContentType[T]>);
-    unknownTypeError(): void;
-    resolveAwaitable<T extends CalledActionResult = any>(handler: (resolve: ((value: T) => void), awaitable: Awaitable<CalledActionResult, T>) => Promise<void> | void, awaitable?: Awaitable<CalledActionResult, T>): Awaitable<CalledActionResult, T>;
-    is<T extends LogicAction.Actions>(parent: new (...args: any[]) => T, type: string): this is T;
-}
+import { ContentNode } from "../action/tree/actionTree";
+import { LogicAction } from "../action/logicAction";
+import { Action } from "../action/action";
+import { Chained, Proxied } from "../action/chain";
+import { Awaitable } from "../../../util/data";
+import { CalledActionResult } from "../gameTypes";
+import type { Story } from "../elements/story";
+export declare class TypedAction<ContentType extends Record<string, any> = Record<string, any>, T extends keyof ContentType & string = keyof ContentType & string, Callee extends LogicAction.GameElement = LogicAction.GameElement> extends Action<ContentType[T], Callee, T> {
+    callee: Callee;
+    constructor(callee: Proxied<Callee, Chained<LogicAction.Actions, Callee>>, type: T, contentNode: ContentNode<ContentType[T]>);
+    unknownTypeError(): void;
+    resolveAwaitable<T extends CalledActionResult = any>(handler: (resolve: ((value: T) => void), awaitable: Awaitable<CalledActionResult, T>) => Promise<void> | void, awaitable?: Awaitable<CalledActionResult, T>): Awaitable<CalledActionResult, T>;
+    is<T extends LogicAction.Actions>(parent: new (...args: any[]) => T, type: string): this is T;
+    /**
+     * {Action Name}#{Action ID}(Action Type){{Action Content}}
+     */
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+    stringifyWithName(name: string): string;
+    stringifyWithContent(name: string, content: string): string;
+}

package/dist/game/nlcore/action/baseElement.d.ts

@@ -1,2 +1,2 @@
-export declare class BaseElement {
-}
+export declare class BaseElement {
+}

package/dist/game/nlcore/action/chain.d.ts

@@ -1,17 +1,17 @@
-import { LogicAction } from "../action/logicAction";
-import { BaseElement } from "../action/baseElement";
-import Actions = LogicAction.Actions;
-import GameElement = LogicAction.GameElement;
-export type Proxied<T extends Record<any, any>, U extends Record<any, any>> = T & U;
-export type ChainedAction = Proxied<GameElement, Chained<LogicAction.Actions>>;
-export type ChainedActions = (ChainedAction | ChainedAction[] | Actions | Actions[])[];
-export declare class Chained<T, Self extends Chainable<any, any> = any> {
-    static isChained<T>(value: any): value is Chained<T>;
-    static toActions(chainedActions: ChainedActions): Actions[];
-}
-/**
- * - T - the action type
- * - U - self constructor
- */
-export declare class Chainable<T, U extends Chainable<any, any>> extends BaseElement {
-}
+import { LogicAction } from "../action/logicAction";
+import { BaseElement } from "../action/baseElement";
+import Actions = LogicAction.Actions;
+import GameElement = LogicAction.GameElement;
+export type Proxied<T extends Record<any, any>, U extends Record<any, any>> = T & U;
+export type ChainedAction = Proxied<GameElement, Chained<LogicAction.Actions>>;
+export type ChainedActions = (ChainedAction | ChainedAction[] | Actions | Actions[])[];
+export declare class Chained<T, Self extends Chainable<any, any> = any> {
+    static isChained<T>(value: any): value is Chained<T>;
+    static toActions(chainedActions: ChainedActions): Actions[];
+}
+/**
+ * - T - the action type
+ * - U - self constructor
+ */
+export declare class Chainable<T, U extends Chainable<any, any>> extends BaseElement {
+}

package/dist/game/nlcore/action/constructable.d.ts

@@ -1,5 +1,5 @@
-import { LogicAction } from "../action/logicAction";
-import { Chainable } from "../action/chain";
-export declare class Constructable<TAction extends LogicAction.Actions = LogicAction.Actions, Self extends Constructable<TAction> = any> extends Chainable<LogicAction.Actions, Self> {
-    constructor();
-}
+import { LogicAction } from "../action/logicAction";
+import { Chainable } from "../action/chain";
+export declare class Constructable<TAction extends LogicAction.Actions = LogicAction.Actions, Self extends Constructable<TAction> = any> extends Chainable<LogicAction.Actions, Self> {
+    constructor();
+}