narraleaf-react 0.5.0 → 0.6.0

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

@@ -1,32 +1,32 @@
-import { Action } from "./action";
-import { ActionHistoryManager } from "./actionHistory";
-type GameHistoryAction = {
-    token: string;
-    action: Action;
-    isPending?: boolean;
-};
-type GameElementHistory = {
-    type: "say";
-    text: string;
-    voice: string | null;
-    character: string | null;
-} | {
-    type: "menu";
-    text: string | null;
-    selected: string | null;
-};
-export type GameHistory = GameHistoryAction & {
-    element: GameElementHistory;
-};
-export declare class GameHistoryManager {
-    private history;
-    private actionHistoryMgr;
-    constructor(actionHistoryMgr: ActionHistoryManager);
-    push(action: GameHistory): this;
-    getHistory(): GameHistory[];
-    reset(): void;
-    updateByToken(id: string, handler: (result: GameHistory | null) => void): void;
-    resolvePending(id: string): void;
-    private crossFilter;
-}
-export {};
+import { Action } from "./action";
+import { ActionHistoryManager } from "./actionHistory";
+type GameHistoryAction = {
+    token: string;
+    action: Action;
+    isPending?: boolean;
+};
+type GameElementHistory = {
+    type: "say";
+    text: string;
+    voice: string | null;
+    character: string | null;
+} | {
+    type: "menu";
+    text: string | null;
+    selected: string | null;
+};
+export type GameHistory = GameHistoryAction & {
+    element: GameElementHistory;
+};
+export declare class GameHistoryManager {
+    private history;
+    private actionHistoryMgr;
+    constructor(actionHistoryMgr: ActionHistoryManager);
+    push(action: GameHistory): this;
+    getHistory(): GameHistory[];
+    reset(): void;
+    updateByToken(id: string, handler: (result: GameHistory | null) => void): void;
+    resolvePending(id: string): void;
+    private crossFilter;
+}
+export {};

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

@@ -1,52 +1,52 @@
-import type { Character } from "../elements/character";
-import type { Scene } from "../elements/scene";
-import type { Story } from "../elements/story";
-import type { Image } from "../elements/displayable/image";
-import type { Condition } from "../elements/condition";
-import type { Script } from "../elements/script";
-import type { Menu } from "../elements/menu";
-import { StringKeyOf, Values } from "../../../util/data";
-import { TypedAction } from "../action/actions";
-import { Sound } from "../elements/sound";
-import { Control } from "../elements/control";
-import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, DisplayableActionContentType, DisplayableActionTypes, ImageActionContentType, ImageActionTypes, LayerActionContentType, LayerActionTypes, MenuActionContentType, MenuActionTypes, PersistentActionContentType, PersistentActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, StoryActionContentType, StoryActionTypes, TextActionContentType, VideoActionContentType, VideoActionTypes } from "../action/actionTypes";
-import { CharacterAction } from "../action/actions/characterAction";
-import { SceneAction } from "../action/actions/sceneAction";
-import { StoryAction } from "../action/actions/storyAction";
-import { ImageAction } from "../action/actions/imageAction";
-import { ConditionAction } from "../action/actions/conditionAction";
-import { ScriptAction } from "../action/actions/scriptAction";
-import { MenuAction } from "../action/actions/menuAction";
-import { SoundAction } from "../action/actions/soundAction";
-import { ControlAction } from "../action/actions/controlAction";
-import { Text } from "../elements/displayable/text";
-import { TextAction } from "../action/actions/textAction";
-import { Displayable as AbstractDisplayable } from "../elements/displayable/displayable";
-import { DisplayableAction } from "../action/actions/displayableAction";
-import { Persistent } from "../elements/persistent";
-import { PersistentAction } from "../action/actions/persistentAction";
-import { ServiceSkeleton } from "../elements/service";
-import { ServiceAction, ServiceActionContentType } from "../action/serviceAction";
-import { Layer } from "../elements/layer";
-import { LayerAction } from "../action/actions/layerAction";
-import { ExposedStateType } from "../../player/type";
-import { Video } from "../elements/video";
-import { VideoAction } from "../action/actions/videoAction";
-export interface LogicActionInterface {
-    DisplayableElements: Text | Image | Layer | AbstractDisplayable<any, any>;
-    DisplayableExposed: ExposedStateType.image | ExposedStateType.layer | ExposedStateType.text;
-    GameElement: Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control | Text | AbstractDisplayable<any, any> | Persistent<any> | ServiceSkeleton | Video;
-    Actions: TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction | TextAction | DisplayableAction | PersistentAction | ServiceAction | LayerAction | VideoAction;
-    ActionTypes: Values<typeof CharacterActionTypes> | Values<typeof ConditionActionTypes> | Values<typeof ImageActionTypes> | Values<typeof SceneActionTypes> | Values<typeof ScriptActionTypes> | Values<typeof StoryActionTypes> | Values<typeof MenuActionTypes> | Values<typeof SoundAction.ActionTypes> | Values<typeof ControlAction.ActionTypes> | Values<typeof TextAction.ActionTypes> | Values<typeof DisplayableActionTypes> | Values<typeof PersistentActionTypes> | StringKeyOf<ServiceActionContentType> | Values<typeof LayerActionTypes> | Values<typeof VideoActionTypes>;
-    ActionContents: CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType & TextActionContentType & DisplayableActionContentType & PersistentActionContentType & ServiceActionContentType & LayerActionContentType & VideoActionContentType;
-}
-export declare const LogicAction: {};
-export declare namespace LogicAction {
-    type DisplayableElements = Text | Image | Layer | AbstractDisplayable<any, any>;
-    type DisplayableExposed = ExposedStateType.image | ExposedStateType.layer | ExposedStateType.text;
-    type GameElement = Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control | Text | AbstractDisplayable<any, any> | Persistent<any> | ServiceSkeleton | Video;
-    type Actions = TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction | TextAction | DisplayableAction | PersistentAction | ServiceAction | LayerAction | VideoAction;
-    type ActionTypes = Values<typeof CharacterActionTypes> | Values<typeof ConditionActionTypes> | Values<typeof ImageActionTypes> | Values<typeof SceneActionTypes> | Values<typeof ScriptActionTypes> | Values<typeof StoryActionTypes> | Values<typeof MenuActionTypes> | Values<typeof SoundAction.ActionTypes> | Values<typeof ControlAction.ActionTypes> | Values<typeof TextAction.ActionTypes> | Values<typeof DisplayableActionTypes> | Values<typeof PersistentActionTypes> | StringKeyOf<ServiceActionContentType> | Values<typeof LayerActionTypes> | Values<typeof VideoActionTypes>;
-    type ActionContents = CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType & TextActionContentType & DisplayableActionContentType & PersistentActionContentType & ServiceActionContentType & LayerActionContentType & VideoActionContentType;
-}
-export type LogicAction = typeof LogicAction;
+import type { Character } from "../elements/character";
+import type { Scene } from "../elements/scene";
+import type { Story } from "../elements/story";
+import type { Image } from "../elements/displayable/image";
+import type { Condition } from "../elements/condition";
+import type { Script } from "../elements/script";
+import type { Menu } from "../elements/menu";
+import { StringKeyOf, Values } from "../../../util/data";
+import { TypedAction } from "../action/actions";
+import { Sound } from "../elements/sound";
+import { Control } from "../elements/control";
+import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, DisplayableActionContentType, DisplayableActionTypes, ImageActionContentType, ImageActionTypes, LayerActionContentType, LayerActionTypes, MenuActionContentType, MenuActionTypes, PersistentActionContentType, PersistentActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, StoryActionContentType, StoryActionTypes, TextActionContentType, VideoActionContentType, VideoActionTypes } from "../action/actionTypes";
+import { CharacterAction } from "../action/actions/characterAction";
+import { SceneAction } from "../action/actions/sceneAction";
+import { StoryAction } from "../action/actions/storyAction";
+import { ImageAction } from "../action/actions/imageAction";
+import { ConditionAction } from "../action/actions/conditionAction";
+import { ScriptAction } from "../action/actions/scriptAction";
+import { MenuAction } from "../action/actions/menuAction";
+import { SoundAction } from "../action/actions/soundAction";
+import { ControlAction } from "../action/actions/controlAction";
+import { Text } from "../elements/displayable/text";
+import { TextAction } from "../action/actions/textAction";
+import { Displayable as AbstractDisplayable } from "../elements/displayable/displayable";
+import { DisplayableAction } from "../action/actions/displayableAction";
+import { Persistent } from "../elements/persistent";
+import { PersistentAction } from "../action/actions/persistentAction";
+import { ServiceSkeleton } from "../elements/service";
+import { ServiceAction, ServiceActionContentType } from "../action/serviceAction";
+import { Layer } from "../elements/layer";
+import { LayerAction } from "../action/actions/layerAction";
+import { ExposedStateType } from "../../player/type";
+import { Video } from "../elements/video";
+import { VideoAction } from "../action/actions/videoAction";
+export interface LogicActionInterface {
+    DisplayableElements: Text | Image | Layer | AbstractDisplayable<any, any>;
+    DisplayableExposed: ExposedStateType.image | ExposedStateType.layer | ExposedStateType.text;
+    GameElement: Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control | Text | AbstractDisplayable<any, any> | Persistent<any> | ServiceSkeleton | Video;
+    Actions: TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction | TextAction | DisplayableAction | PersistentAction | ServiceAction | LayerAction | VideoAction;
+    ActionTypes: Values<typeof CharacterActionTypes> | Values<typeof ConditionActionTypes> | Values<typeof ImageActionTypes> | Values<typeof SceneActionTypes> | Values<typeof ScriptActionTypes> | Values<typeof StoryActionTypes> | Values<typeof MenuActionTypes> | Values<typeof SoundAction.ActionTypes> | Values<typeof ControlAction.ActionTypes> | Values<typeof TextAction.ActionTypes> | Values<typeof DisplayableActionTypes> | Values<typeof PersistentActionTypes> | StringKeyOf<ServiceActionContentType> | Values<typeof LayerActionTypes> | Values<typeof VideoActionTypes>;
+    ActionContents: CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType & TextActionContentType & DisplayableActionContentType & PersistentActionContentType & ServiceActionContentType & LayerActionContentType & VideoActionContentType;
+}
+export declare const LogicAction: {};
+export declare namespace LogicAction {
+    type DisplayableElements = Text | Image | Layer | AbstractDisplayable<any, any>;
+    type DisplayableExposed = ExposedStateType.image | ExposedStateType.layer | ExposedStateType.text;
+    type GameElement = Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control | Text | AbstractDisplayable<any, any> | Persistent<any> | ServiceSkeleton | Video;
+    type Actions = TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction | TextAction | DisplayableAction | PersistentAction | ServiceAction | LayerAction | VideoAction;
+    type ActionTypes = Values<typeof CharacterActionTypes> | Values<typeof ConditionActionTypes> | Values<typeof ImageActionTypes> | Values<typeof SceneActionTypes> | Values<typeof ScriptActionTypes> | Values<typeof StoryActionTypes> | Values<typeof MenuActionTypes> | Values<typeof SoundAction.ActionTypes> | Values<typeof ControlAction.ActionTypes> | Values<typeof TextAction.ActionTypes> | Values<typeof DisplayableActionTypes> | Values<typeof PersistentActionTypes> | StringKeyOf<ServiceActionContentType> | Values<typeof LayerActionTypes> | Values<typeof VideoActionTypes>;
+    type ActionContents = CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType & TextActionContentType & DisplayableActionContentType & PersistentActionContentType & ServiceActionContentType & LayerActionContentType & VideoActionContentType;
+}
+export type LogicAction = typeof LogicAction;

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

@@ -1,11 +1,24 @@
-import { TypedAction } from "../action/actions";
-import { Awaitable, StringKeyOf } from "../../../util/data";
-import { ServiceSkeleton } from "../elements/service";
-import { GameState } from "../../player/gameState";
-import { CalledActionResult } from "../gameTypes";
-export type ServiceActionContentType = {
-    "service:action": [type: string, args: unknown[]];
-};
-export declare class ServiceAction extends TypedAction<ServiceActionContentType, StringKeyOf<ServiceActionContentType>, ServiceSkeleton> {
-    executeAction(gameState: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
+import { TypedAction } from "../action/actions";
+import { ServiceSkeleton } from "../elements/service";
+import { Awaitable, StringKeyOf } from "../../../util/data";
+import { GameState } from "../../player/gameState";
+import { ActionExecutionInjection } from "./action";
+import { LogicAction } from "../action/logicAction";
+import { Story } from "../elements/story";
+export type ServiceActionContentType = {
+    "service:action": [type: string, args: unknown[]];
+};
+export declare class ServiceAction extends TypedAction<ServiceActionContentType, StringKeyOf<ServiceActionContentType>, ServiceSkeleton> {
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): {
+        type: any;
+        node: import("./tree/actionTree").ContentNode<any> | null;
+        wait?: import("../gameTypes").StackModelWaiting | null;
+    } | Awaitable<import("../gameTypes").CalledActionResult, any> | (import("../gameTypes").CalledActionResult | Awaitable<import("../gameTypes").CalledActionResult, any>)[] | Awaitable<{
+        type: any;
+        node: import("./tree/actionTree").RenderableNode | null;
+    }, {
+        type: any;
+        node: import("./tree/actionTree").RenderableNode | null;
+    }> | null;
+    stringify(_story: Story, _seen: Set<LogicAction.Actions>, _strict: boolean): string;
+}

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

@@ -1,47 +1,47 @@
-import { Sound } from "../elements/sound";
-import { Image } from "../elements/displayable/image";
-import { Story } from "../common/core";
-import { StaticImageData } from "../types";
-import { LogicAction } from "../action/logicAction";
-export type SrcType = "image" | "video" | "audio";
-export type Src = {
-    type: "image";
-    src: Image | string;
-} | {
-    type: "video";
-    src: string;
-} | {
-    type: "audio";
-    src: Sound;
-};
-export type ActiveSrc<T extends "scene" | "once" = "scene" | "once"> = Src & {
-    activeType: T;
-};
-export declare class SrcManager {
-    static SrcTypes: {
-        [key in SrcType]: key;
-    };
-    static catSrc(src: Src[]): {
-        image: (Image | string)[];
-        video: string[];
-        audio: Sound[];
-    };
-    static getSrc(src: Src | string | Image): string | null;
-    static getPreloadableSrc(story: Story, action: LogicAction.Actions): (Src & {
-        activeType: "scene" | "once";
-    }) | null;
-    src: Src[];
-    future: SrcManager[];
-    register(src: Src): this;
-    register(src: Src[]): this;
-    register(src: Sound): this;
-    register(src: Image | StaticImageData): this;
-    register(type: SrcType, src: Src["src"]): this;
-    registerRawSrc(src: string): this;
-    isSrcRegistered(src: string | Sound | Image | null): boolean;
-    getSrc(): Src[];
-    getSrcByType(type: SrcType): Src[];
-    registerFuture(srcManager: SrcManager): this;
-    hasFuture(s: SrcManager): boolean;
-    getFutureSrc(): Src[];
-}
+import { Sound } from "../elements/sound";
+import { Image } from "../elements/displayable/image";
+import { Story } from "../common/core";
+import { StaticImageData } from "../types";
+import { LogicAction } from "../action/logicAction";
+export type SrcType = "image" | "video" | "audio";
+export type Src = {
+    type: "image";
+    src: Image | string;
+} | {
+    type: "video";
+    src: string;
+} | {
+    type: "audio";
+    src: Sound;
+};
+export type ActiveSrc<T extends "scene" | "once" = "scene" | "once"> = Src & {
+    activeType: T;
+};
+export declare class SrcManager {
+    static SrcTypes: {
+        [key in SrcType]: key;
+    };
+    static catSrc(src: Src[]): {
+        image: (Image | string)[];
+        video: string[];
+        audio: Sound[];
+    };
+    static getSrc(src: Src | string | Image): string | null;
+    static getPreloadableSrc(story: Story, action: LogicAction.Actions): (Src & {
+        activeType: "scene" | "once";
+    }) | null;
+    src: Src[];
+    future: SrcManager[];
+    register(src: Src): this;
+    register(src: Src[]): this;
+    register(src: Sound): this;
+    register(src: Image | StaticImageData): this;
+    register(type: SrcType, src: Src["src"]): this;
+    registerRawSrc(src: string): this;
+    isSrcRegistered(src: string | Sound | Image | null): boolean;
+    getSrc(): Src[];
+    getSrcByType(type: SrcType): Src[];
+    registerFuture(srcManager: SrcManager): this;
+    hasFuture(s: SrcManager): boolean;
+    getFutureSrc(): Src[];
+}

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

@@ -0,0 +1,106 @@
+import { Awaitable } from "../../../util/data";
+import { LiveGame } from "../common/game";
+import { CalledActionResult, StackModelWaiting } from "../gameTypes";
+import { LogicAction } from "./logicAction";
+export declare enum StackModelItemType {
+    Action = "action",
+    Link = "link"
+}
+export type StackModelRawData = ({
+    type: StackModelItemType.Action;
+    actionType: string | null;
+    action: string | null;
+} | {
+    type: StackModelItemType.Link;
+    actionType: string | null;
+    action: string | null;
+    stacks: StackModelRawData[];
+    stackWaitType: StackModelWaiting["type"] | null;
+})[];
+/**
+ * Nested Stack Model is a new concept designed to control serialization/deserialization of complex nested operations
+ *
+ * Core concepts for saving state:
+ * 1. Do not save operations that cannot be immediately resolved, such as Awaitables
+ * 2. If an action returns an Awaitable, to prevent re-execution of the previous operation after deserialization:
+ *    - Store the operation in waitingAction and add it to the tail stack during serialization
+ *    - When restoring data, retrying the tail stack operation will retry this operation
+ *    - Awaitables should not be saved due to their scope and complex behavior, instead save their parent operation
+ * 3. If an action returns a regular child (synchronous operation), add it to the tail stack
+ *    - The child will continue on the next stack operation
+ * 4. If an action returns multiple children, add them sequentially to the tail stack
+ *    - These children are treated as having a call relationship, e.g. in [a,b], a waits for b to complete before continuing
+ *    - This requires all elements except the stack top to be fully synchronous operations
+ * 5. If an action returns a StackAction (not yet implemented), wait according to the StackAction definition
+ *    - This operation is considered semi-synchronous since it contains child information
+ *    - Serialization mechanism: treat as synchronous operation, including async info and stack contents
+ *    - When restored, operation remains at stack top and continues waiting for stack operations to complete
+ *    - This ensures stack operations are not abnormally re-executed or skipped after deserialization
+ *
+ * Example scenarios:
+ * 1. Action returns Awaitable:
+ *    - Async operation: add Awaitable to tail stack, set sync operation as waitingAction
+ *    - During save: exclude Awaitable, add waitingAction to stack for retry on deserialize
+ *    - During runtime: wait for resolution, pop self and add return value to stack
+ * 2. Action returns direct child:
+ *    - Sync operation: add operation to tail stack
+ *    - During save: add operation to stack
+ *    - During runtime: pop self and add child to stack
+ * 3. Action returns multiple children:
+ *    - Sync/async nature determined by last child
+ *    - Push all children to stack in order, last child on top
+ *    - Save behavior follows above rules
+ * 4. Action returns StackAction:
+ *    - Semi-sync operation treated as sync, includes async info and stack contents
+ *    - During save: includes direct children, wait info (type e.g. any, all) and stack
+ *    - Runtime with non-empty stack: continue waiting for stack operations
+ *    - Runtime with empty stack: resolve operation, pop self and add direct children
+ * 5. Action returns direct child but async executes StackModel:
+ *    - Serialize StackModel and execute directly on deserialize
+ */
+export declare class StackModel {
+    private liveGame;
+    __tag: string | undefined;
+    static isStackModel(action: CalledActionResult | Awaitable<CalledActionResult> | StackModel): action is StackModel;
+    static createStackModel(liveGame: LiveGame, data: StackModelRawData, actionMap: Map<string, LogicAction.Actions>): StackModel;
+    static isCalledActionResult(action: CalledActionResult | Awaitable<CalledActionResult> | StackModel | undefined | null): action is CalledActionResult;
+    static fromAction(action: LogicAction.Actions): CalledActionResult;
+    static executeStackModelGroup(type: StackModelWaiting["type"], stackModels: StackModel[]): Awaitable<void>;
+    static isStackModelsAwaiting(type: StackModelWaiting["type"], stackModels: StackModel[]): boolean;
+    private stack;
+    private waitingAction;
+    constructor(liveGame: LiveGame, tag?: string | undefined);
+    /**
+     * Executes the next operation in the stack
+     *
+     * Main responsibilities:
+     * 1. Check and handle waiting states at the top of the stack
+     * 2. Execute current operation and handle its results
+     * 3. Manage asynchronous operations and nested stack models
+     *
+     * Execution flow:
+     * 1. If stack is empty, return null
+     * 2. Check top element:
+     *    - If it's an unsettled Awaitable, return the Awaitable
+     *    - If it's a waiting operation (with nested stack models), check nested stack status
+     * 3. Pop and execute current operation:
+     *    - If it's an Awaitable, wait for completion and handle result
+     *    - If it's a regular operation, execute and handle return value
+     *
+     * @returns One of the following:
+     * - CalledActionResult: Execution result (returned a synchronous operation)
+     * - Awaitable<CalledActionResult>: Asynchronous operation
+     * - null: No more operations if the stack is empty, or the top element is exited
+     */
+    rollNext(): CalledActionResult | Awaitable<CalledActionResult> | null;
+    execute(): Awaitable<void>;
+    abortStackTop(): CalledActionResult | null;
+    getTopSync(): CalledActionResult | null;
+    executeActions(result: CalledActionResult): CalledActionResult | Awaitable<CalledActionResult> | null;
+    isWaiting(): boolean;
+    serialize(): StackModelRawData;
+    reset(): void;
+    deserialize(data: StackModelRawData, actionMap: Map<string, LogicAction.Actions>): this;
+    isEmpty(): boolean;
+    push(...items: (CalledActionResult | Awaitable<CalledActionResult>)[]): this;
+}

package/dist/game/nlcore/action/tree/actionTree.d.ts

@@ -1,56 +1,56 @@
-import { LogicAction } from "../../action/logicAction";
-export declare enum NodeType {
-    TreeNode = "TreeNode",
-    ContentNode = "ContentNode"
-}
-export type RawData<T> = {
-    id: string;
-    data: T;
-};
-export declare class Node<C = any> {
-    type: string;
-    content: C | undefined;
-    constructor(type: string);
-    setContent(content: C): this;
-    getContent(): C;
-}
-export type RenderableNode = ContentNode;
-export type RenderableNodeData = ContentNodeData | TreeNodeData;
-export type ContentNodeData = {
-    id: string;
-    data: any;
-};
-export declare class ContentNode<T = any> extends Node<T> {
-    static create<T>(content: T): ContentNode<T>;
-    static forEachParent(node: RenderableNode, callback: (node: RenderableNode) => void): void;
-    static forEachChild(node: RenderableNode, callback: (node: RenderableNode) => void): void;
-    action: LogicAction.Actions | null;
-    private child?;
-    private parent;
-    constructor(callee?: LogicAction.Actions, parent?: RenderableNode | null, child?: RenderableNode);
-    setParent(parent: RenderableNode | null): this;
-    setChild(child: RenderableNode | null): this;
-    getChild(): RenderableNode | null;
-    getParent(): RenderableNode | null;
-    /**
-     * Public method for setting the content of the node
-     * should only be called when changing the state in-game
-     */
-    addChild(child: RenderableNode | null): this;
-    removeChild(child: RenderableNode | null): this;
-    /**
-     * Remove this node from the parent's children
-     */
-    remove(): this;
-    hasChild(): boolean;
-}
-export declare class RootNode extends ContentNode {
-    constructor();
-    setParent(_: RenderableNode | null): this;
-    remove(): this;
-    forEach(callback: (node: RenderableNode) => void): void;
-}
-export type TreeNodeData = {
-    id: string;
-    data: any;
-};
+import { LogicAction } from "../../action/logicAction";
+export declare enum NodeType {
+    TreeNode = "TreeNode",
+    ContentNode = "ContentNode"
+}
+export type RawData<T> = {
+    id: string;
+    data: T;
+};
+export declare class Node<C = any> {
+    type: string;
+    content: C | undefined;
+    constructor(type: string);
+    setContent(content: C): this;
+    getContent(): C;
+}
+export type RenderableNode = ContentNode;
+export type RenderableNodeData = ContentNodeData | TreeNodeData;
+export type ContentNodeData = {
+    id: string;
+    data: any;
+};
+export declare class ContentNode<T = any> extends Node<T> {
+    static create<T>(content: T): ContentNode<T>;
+    static forEachParent(node: RenderableNode, callback: (node: RenderableNode) => void): void;
+    static forEachChild(node: RenderableNode, callback: (node: RenderableNode) => void): void;
+    action: LogicAction.Actions | null;
+    private child?;
+    private parent;
+    constructor(callee?: LogicAction.Actions, parent?: RenderableNode | null, child?: RenderableNode);
+    setParent(parent: RenderableNode | null): this;
+    setChild(child: RenderableNode | null): this;
+    getChild(): RenderableNode | null;
+    getParent(): RenderableNode | null;
+    /**
+     * Public method for setting the content of the node
+     * should only be called when changing the state in-game
+     */
+    addChild(child: RenderableNode | null): this;
+    removeChild(child: RenderableNode | null): this;
+    /**
+     * Remove this node from the parent's children
+     */
+    remove(): this;
+    hasChild(): boolean;
+}
+export declare class RootNode extends ContentNode {
+    constructor();
+    setParent(_: RenderableNode | null): this;
+    remove(): this;
+    forEach(callback: (node: RenderableNode) => void): void;
+}
+export type TreeNodeData = {
+    id: string;
+    data: any;
+};

package/dist/game/nlcore/common/Utils.d.ts

@@ -1,25 +1,25 @@
-import type { Color, HexColor } from "../types";
-import { Word } from "../elements/character/word";
-export declare class RGBColor {
-    static isHexString(color: any): color is HexColor;
-    static fromHex(hex: HexColor): RGBColor;
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-    constructor(r: number, g: number, b: number, a?: number);
-    toString(): string;
-    toHex(): string;
-}
-/**
- * Alias for {@link Word.color}
- */
-export declare function c(text: string | Word, color: Color): Word;
-/**
- * Alias for {@link Word.bold}
- */
-export declare function b(text: string | Word): Word;
-/**
- * Alias for {@link Word.italic}
- */
-export declare function i(text: string | Word): Word;
+import type { Color, HexColor } from "../types";
+import { Word } from "../elements/character/word";
+export declare class RGBColor {
+    static isHexString(color: any): color is HexColor;
+    static fromHex(hex: HexColor): RGBColor;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    toString(): string;
+    toHex(): string;
+}
+/**
+ * Alias for {@link Word.color}
+ */
+export declare function c(text: string | Word, color: Color): Word;
+/**
+ * Alias for {@link Word.bold}
+ */
+export declare function b(text: string | Word): Word;
+/**
+ * Alias for {@link Word.italic}
+ */
+export declare function i(text: string | Word): Word;

package/dist/game/nlcore/common/core.d.ts

@@ -1,8 +1,8 @@
-import { i, c, b } from "./Utils";
-export * from "./elements";
-export * from "./game";
-export * from "./player";
-export * from "./types";
-export * from "./position";
-export * from "./transition";
-export { i, c, b, };
+import { i, c, b } from "./Utils";
+export * from "./elements";
+export * from "./game";
+export * from "./player";
+export * from "./types";
+export * from "./position";
+export * from "./transition";
+export { i, c, b, };

package/dist/game/nlcore/common/elements.d.ts

@@ -1,19 +1,19 @@
-import { Character } from "../elements/character";
-import { Condition, Lambda } from "../elements/condition";
-import { Control } from "../elements/control";
-import { Image } from "../elements/displayable/image";
-import { Menu } from "../elements/menu";
-import { Scene } from "../elements/scene";
-import { Script } from "../elements/script";
-import { Sound } from "../elements/sound";
-import { Story } from "../elements/story";
-import { Transform } from "../elements/transform/transform";
-import { Sentence } from "../elements/character/sentence";
-import { Word } from "../elements/character/word";
-import { Text } from "../elements/displayable/text";
-import { Pause } from "../elements/character/pause";
-import { Persistent } from "../elements/persistent";
-import { Service } from "../elements/service";
-import { Layer } from "../elements/layer";
-import { Video } from "../elements/video";
-export { Character, Condition, Control, Image, Lambda, Menu, Scene, Script, Sentence, Sound, Story, Transform, Word, Text, Pause, Persistent, Service, Layer, Video, };
+import { Character } from "../elements/character";
+import { Condition, Lambda } from "../elements/condition";
+import { Control } from "../elements/control";
+import { Image } from "../elements/displayable/image";
+import { Menu } from "../elements/menu";
+import { Scene } from "../elements/scene";
+import { Script } from "../elements/script";
+import { Sound } from "../elements/sound";
+import { Story } from "../elements/story";
+import { Transform } from "../elements/transform/transform";
+import { Sentence } from "../elements/character/sentence";
+import { Word } from "../elements/character/word";
+import { Text } from "../elements/displayable/text";
+import { Pause } from "../elements/character/pause";
+import { Persistent } from "../elements/persistent";
+import { Service } from "../elements/service";
+import { Layer } from "../elements/layer";
+import { Video } from "../elements/video";
+export { Character, Condition, Control, Image, Lambda, Menu, Scene, Script, Sentence, Sound, Story, Transform, Word, Text, Pause, Persistent, Service, Layer, Video, };