narraleaf-react 0.0.1-beta.1

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

@@ -0,0 +1,19 @@
+import { LogicAction } from "./logicAction";
+import { ContentNode } from "../action/tree/actionTree";
+import type { CalledActionResult } from "@core/gameTypes";
+import { Awaitable } from "../../../util/data";
+import { GameState } from "../../player/gameState";
+export declare class Action<ContentNodeType = any, Callee = LogicAction.GameElement> {
+    static ActionTypes: {
+        action: string;
+    };
+    callee: Callee;
+    type: ContentNodeType;
+    contentNode: ContentNode<ContentNodeType>;
+    _id: string;
+    readonly __stack: string;
+    constructor(callee: Callee, type: ContentNodeType, contentNode: ContentNode<ContentNodeType>);
+    executeAction(_state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+    getId(): string;
+    getFutureActions(): LogicAction.Actions[];
+}

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

@@ -0,0 +1,103 @@
+import { LogicAction } from "../action/logicAction";
+import type { Story } from "../elements/story";
+import type { ConditionData } from "../elements/condition";
+import { Background, CommonImage } from "../types";
+import { Transform } from "../elements/transform/transform";
+import type { Scene } from "../elements/scene";
+import type { Sentence } from "../elements/text";
+import type { MenuData } from "../elements/menu";
+import { Awaitable } from "../../../util/data";
+import { ITransition } from "../elements/transition/type";
+import type { Sound } from "../elements/sound";
+import type { Script } from "../elements/script";
+export declare const CharacterActionTypes: {
+    readonly say: "character:say";
+    readonly action: "character:action";
+};
+export type CharacterActionContentType = {
+    [K in typeof CharacterActionTypes[keyof typeof CharacterActionTypes]]: K extends "character:say" ? Sentence : K extends "character:action" ? any : any;
+};
+export declare const SceneActionTypes: {
+    readonly action: "scene:action";
+    readonly setBackground: "scene:setBackground";
+    readonly sleep: "scene:sleep";
+    readonly setTransition: "scene:setTransition";
+    readonly applyTransition: "scene:applyTransition";
+    readonly init: "scene:init";
+    readonly exit: "scene:exit";
+    readonly jumpTo: "scene:jumpTo";
+    readonly setBackgroundMusic: "scene:setBackgroundMusic";
+    readonly preUnmount: "scene:preUnmount";
+    readonly applyTransform: "scene:applyTransform";
+};
+export type SceneActionContentType = {
+    [K in typeof SceneActionTypes[keyof typeof SceneActionTypes]]: K extends typeof SceneActionTypes["action"] ? Scene : K extends typeof SceneActionTypes["sleep"] ? number | Promise<any> | Awaitable<any, any> : K extends typeof SceneActionTypes["setBackground"] ? [Background["background"]] : K extends typeof SceneActionTypes["setTransition"] ? [ITransition | null] : K extends typeof SceneActionTypes["applyTransition"] ? [ITransition] : K extends typeof SceneActionTypes["init"] ? [] : K extends typeof SceneActionTypes["exit"] ? [] : K extends typeof SceneActionTypes["jumpTo"] ? [Scene] : K extends typeof SceneActionTypes["setBackgroundMusic"] ? [Sound, number?] : K extends typeof SceneActionTypes["preUnmount"] ? [] : K extends typeof SceneActionTypes["applyTransform"] ? [Transform] : any;
+};
+export declare const StoryActionTypes: {
+    readonly action: "story:action";
+};
+export type StoryActionContentType = {
+    [K in typeof StoryActionTypes[keyof typeof StoryActionTypes]]: K extends "story:action" ? Story : any;
+};
+export declare const ImageActionTypes: {
+    readonly action: "image:action";
+    readonly setSrc: "image:setSrc";
+    readonly setPosition: "image:setPosition";
+    readonly show: "image:show";
+    readonly hide: "image:hide";
+    readonly applyTransform: "image:applyTransform";
+    readonly init: "image:init";
+    readonly dispose: "image:dispose";
+    readonly setTransition: "image:setTransition";
+    readonly applyTransition: "image:applyTransition";
+};
+export type ImageActionContentType = {
+    [K in typeof ImageActionTypes[keyof typeof ImageActionTypes]]: K extends "image:setSrc" ? [string] : K extends "image:setPosition" ? [CommonImage["position"], Transform] : K extends "image:show" ? [void, Transform] : K extends "image:hide" ? [void, Transform] : K extends "image:applyTransform" ? [void, Transform, string] : K extends "image:init" ? [Scene?] : K extends "image:dispose" ? [] : K extends "image:setTransition" ? [ITransition | null] : K extends "image:applyTransition" ? [ITransition] : any;
+};
+export declare const ConditionActionTypes: {
+    readonly action: "condition:action";
+};
+export type ConditionActionContentType = {
+    [K in typeof ConditionActionTypes[keyof typeof ConditionActionTypes]]: K extends "condition:action" ? ConditionData : any;
+};
+export declare const ScriptActionTypes: {
+    readonly action: "script:action";
+};
+export type ScriptActionContentType = {
+    [K in typeof ScriptActionTypes[keyof typeof ScriptActionTypes]]: K extends "script:action" ? Script : any;
+};
+export declare const MenuActionTypes: {
+    readonly action: "menu:action";
+};
+export type MenuActionContentType = {
+    [K in typeof MenuActionTypes[keyof typeof MenuActionTypes]]: K extends "menu:action" ? MenuData : any;
+};
+export declare const SoundActionTypes: {
+    readonly action: "sound:action";
+    readonly play: "sound:play";
+    readonly stop: "sound:stop";
+    readonly fade: "sound:fade";
+    readonly setVolume: "sound:setVolume";
+    readonly setRate: "sound:setRate";
+};
+export type SoundActionContentType = {
+    [K in typeof SoundActionTypes[keyof typeof SoundActionTypes]]: K extends "sound:play" ? [void] : K extends "sound:stop" ? [void] : K extends "sound:fade" ? [
+        {
+            start: number;
+            end: number;
+            duration: number;
+        }
+    ] : K extends "sound:setVolume" ? [number] : K extends "sound:setRate" ? [number] : any;
+};
+export declare const ControlActionTypes: {
+    readonly action: "control:action";
+    readonly do: "control:do";
+    readonly doAsync: "control:doAsync";
+    readonly any: "control:any";
+    readonly all: "control:all";
+    readonly allAsync: "control:allAsync";
+    readonly repeat: "control:repeat";
+};
+export type ControlActionContentType = {
+    [K in typeof ControlActionTypes[keyof typeof ControlActionTypes]]: K extends "control:do" ? [LogicAction.Actions[]] : K extends "control:doAsync" ? [LogicAction.Actions[]] : K extends "control:any" ? [LogicAction.Actions[]] : K extends "control:all" ? [LogicAction.Actions[]] : K extends "control:parallel" ? [LogicAction.Actions[]] : K extends "control:allAsync" ? [LogicAction.Actions[]] : K extends "control:repeat" ? [LogicAction.Actions[], number] : any;
+};

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

@@ -0,0 +1,19 @@
+import { LogicAction } from "../action/logicAction";
+export declare class Actionable<StateData extends Record<string, any> = Record<string, any>> {
+    static IdPrefixes: {
+        readonly Actionable: "actionable";
+        readonly Condition: "$0";
+        readonly Control: "$1";
+        readonly Image: "$2";
+        readonly Script: "$3";
+        readonly Sound: "$4";
+        readonly Text: "$5";
+        readonly Menu: "$6";
+    };
+    readonly id: string;
+    protected actions: LogicAction.Actions[];
+    constructor(idPrefix?: string);
+    toActions(): LogicAction.Actions[];
+    toData(): StateData | null;
+    fromData(_: StateData): this;
+}

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

@@ -0,0 +1,126 @@
+import { ContentNode } from "../action/tree/actionTree";
+import { Awaitable } from "../../../util/data";
+import { Image } from "../elements/image";
+import { LogicAction } from "../action/logicAction";
+import { Action } from "../action/action";
+import type { Character } from "../elements/text";
+import type { Scene } from "../elements/scene";
+import type { Story } from "../elements/story";
+import type { Script } from "../elements/script";
+import type { Menu } from "../elements/menu";
+import type { Condition } from "../elements/condition";
+import type { CalledActionResult } from "@core/gameTypes";
+import { GameState } from "../../player/gameState";
+import type { Sound } from "../elements/sound";
+import { Control } from "../elements/control";
+import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, ControlActionTypes, ImageActionContentType, ImageActionTypes, MenuActionContentType, MenuActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, SoundActionTypes, StoryActionContentType, StoryActionTypes } from "../action/actionTypes";
+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> {
+    callee: Callee;
+    constructor(callee: Callee, type: any, contentNode: ContentNode<ContentType[T]>);
+    unknownType(): void;
+}
+export declare class CharacterAction<T extends typeof CharacterActionTypes[keyof typeof CharacterActionTypes] = typeof CharacterActionTypes[keyof typeof CharacterActionTypes]> extends TypedAction<CharacterActionContentType, T, Character> {
+    static ActionTypes: {
+        readonly say: "character:say";
+        readonly action: "character:action";
+    };
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}
+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 setBackground: "scene:setBackground";
+        readonly sleep: "scene:sleep";
+        readonly setTransition: "scene:setTransition";
+        readonly applyTransition: "scene:applyTransition";
+        readonly init: "scene:init";
+        readonly exit: "scene:exit";
+        readonly jumpTo: "scene:jumpTo";
+        readonly setBackgroundMusic: "scene:setBackgroundMusic";
+        readonly preUnmount: "scene:preUnmount";
+        readonly applyTransform: "scene:applyTransform";
+    };
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+    getFutureActions(): LogicAction.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";
+    };
+}
+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 setPosition: "image:setPosition";
+        readonly show: "image:show";
+        readonly hide: "image:hide";
+        readonly applyTransform: "image:applyTransform";
+        readonly init: "image:init";
+        readonly dispose: "image:dispose";
+        readonly setTransition: "image:setTransition";
+        readonly applyTransition: "image:applyTransition";
+    };
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}
+export declare class ConditionAction<T extends typeof ConditionActionTypes[keyof typeof ConditionActionTypes] = typeof ConditionActionTypes[keyof typeof ConditionActionTypes]> extends TypedAction<ConditionActionContentType, T, Condition> {
+    static ActionTypes: {
+        readonly action: "condition:action";
+    };
+    executeAction(gameState: GameState): {
+        type: any;
+        node: ContentNode<ConditionActionContentType[T]>;
+    };
+    getFutureActions(): LogicAction.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): {
+        type: any;
+        node: ContentNode<ScriptActionContentType[T]>;
+    };
+}
+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(): LogicAction.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 fade: "sound:fade";
+        readonly setVolume: "sound:setVolume";
+        readonly setRate: "sound:setRate";
+    };
+    static initSound(state: GameState, sound: Sound): void;
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}
+export declare class ControlAction<T extends typeof ControlActionTypes[keyof typeof ControlActionTypes] = typeof ControlActionTypes[keyof typeof ControlActionTypes]> extends TypedAction<ControlActionContentType, T, Control> {
+    static ActionTypes: {
+        readonly action: "control:action";
+        readonly do: "control:do";
+        readonly doAsync: "control:doAsync";
+        readonly any: "control:any";
+        readonly all: "control:all";
+        readonly allAsync: "control:allAsync";
+        readonly repeat: "control:repeat";
+    };
+    /**
+     * Execute all actions in the content node
+     * will wait for awaitable actions to resolve
+     */
+    executeAllActions(state: GameState, action: LogicAction.Actions): Promise<void>;
+    executeSingleAction(state: GameState, action: LogicAction.Actions): Promise<TypedAction<Record<string, any>, string, LogicAction.GameElement> | MenuAction<"menu:action"> | ControlAction<"control:action" | "control:do" | "control:doAsync" | "control:any" | "control:all" | "control:allAsync" | "control:repeat"> | ContentNode<any> | null>;
+    execute(state: GameState, awaitable: Awaitable<any, any>, content: LogicAction.Actions[]): Awaitable<any, any> | {
+        type: any;
+        node: ContentNode<any> | null;
+    } | Awaitable<CalledActionResult<any>, any>;
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, CalledActionResult>;
+    getFutureActions(): LogicAction.Actions[];
+}

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

@@ -0,0 +1,40 @@
+import { ContentNode, RenderableNode, RootNode } from "../action/tree/actionTree";
+import { LogicAction } from "../action/logicAction";
+export declare class Constructable<T extends typeof Constructable = any, TAction extends LogicAction.Actions = LogicAction.Actions, CAction extends LogicAction.Actions = LogicAction.Actions> {
+    static targetAction: any;
+    private readonly actions;
+    constructor();
+    setRoot(root: RootNode): LogicAction.Actions | undefined;
+    getActions(): TAction[];
+    setActions(actions: TAction[]): void;
+    /**@internal */
+    getAllActions(includeJumpTo?: boolean, actions?: LogicAction.Actions[]): LogicAction.Actions[];
+    /**@internal */
+    forEachAction(callback: (action: LogicAction.Actions) => void, includeJumpTo?: boolean, actions?: LogicAction.Actions[]): void;
+    /**@internal */
+    findActionById(id: string, actions?: LogicAction.Actions[]): LogicAction.Actions | null;
+    /**@internal */
+    getAllElements(actions?: LogicAction.Actions[]): LogicAction.GameElement[];
+    /**@internal */
+    getActionsByType(type: LogicAction.ActionTypes, actions?: LogicAction.Actions[]): LogicAction.Actions[];
+    /**@internal */
+    getAllNodes(actions?: LogicAction.Actions[]): ContentNode[];
+    /**@internal */
+    findNodeById(id: string, actions?: LogicAction.Actions[]): ContentNode | null;
+    /**@internal */
+    findElementById(id: string, elements: LogicAction.GameElement[]): LogicAction.GameElement | null;
+    /**
+     * @internal
+     * Find multiple elements by multiple IDs
+     */
+    findElementsByIds(ids: string[], elements: LogicAction.GameElement[]): LogicAction.GameElement[];
+    /**
+     * Adds an action to the current specified context instance
+     */
+    protected _action(actions: (callee: this) => (TAction | TAction[])[]): CAction;
+    protected _action(actions: (TAction | TAction[])[]): CAction;
+    /**
+     * Construct the actions into a tree
+     */
+    protected construct(parent?: RenderableNode): RenderableNode | null;
+}

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

@@ -0,0 +1,18 @@
+import type { Character } from "../elements/text";
+import type { Scene } from "../elements/scene";
+import type { Story } from "../elements/story";
+import type { Image } from "../elements/image";
+import type { Condition } from "../elements/condition";
+import type { Script } from "../elements/script";
+import type { Menu } from "../elements/menu";
+import { Values } from "../../../util/data";
+import { CharacterAction, ConditionAction, ControlAction, ImageAction, MenuAction, SceneAction, ScriptAction, SoundAction, StoryAction, TypedAction } from "../action/actions";
+import { Sound } from "../elements/sound";
+import { Control } from "../elements/control";
+import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, ImageActionContentType, ImageActionTypes, MenuActionContentType, MenuActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, StoryActionContentType, StoryActionTypes } from "../action/actionTypes";
+export declare namespace LogicAction {
+    type GameElement = Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control;
+    type Actions = (TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction);
+    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>;
+    type ActionContents = CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType;
+}

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

@@ -0,0 +1,62 @@
+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> {
+    id: string;
+    type: string;
+    content: C | undefined;
+    constructor(id: string, 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 forEachParent(node: RenderableNode, callback: (node: RenderableNode) => void): void;
+    static forEachChild(node: RenderableNode, callback: (node: RenderableNode) => void): void;
+    child?: RenderableNode | null;
+    initChild?: RenderableNode | null;
+    parent: RenderableNode | null;
+    action: LogicAction.Actions | null;
+    constructor(id: string, callee?: LogicAction.Actions, parent?: RenderableNode | null, child?: RenderableNode);
+    setParent(parent: RenderableNode | null): this;
+    setChild(child: RenderableNode | null): this;
+    getChild(): RenderableNode | null;
+    getParent(): RenderableNode | null;
+    /**
+     * To track the changes of the child
+     * should only be called when constructing the tree
+     */
+    setInitChild(child: RenderableNode): this;
+    /**
+     * 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

@@ -0,0 +1,33 @@
+import type { Background, NextJSStaticImageData } from "../types";
+import type { Scene } from "../elements/scene";
+import type { Image } from "../elements/image";
+export declare class Utils {
+    static srcToString(src: string | NextJSStaticImageData): string;
+    static staticImageDataToSrc(image: NextJSStaticImageData | string): string;
+    static isStaticImageData(src: any): src is NextJSStaticImageData;
+    static backgroundToSrc(background: Background["background"]): any;
+    static isExternalSrc(src: string): boolean;
+}
+export declare class UseError<T = Record<string, any>> extends Error {
+    private props;
+    constructor(message: string, props: T, name?: string);
+    static isUseError(error: any): error is UseError;
+}
+export declare class StaticScriptWarning extends UseError<{
+    stack?: string;
+}> {
+    static isWarning(error: any): error is StaticScriptWarning;
+    constructor(message: string);
+}
+type ImageState = {
+    isDisposed: boolean;
+    usedExternalSrc: boolean;
+};
+export declare class StaticChecker {
+    private readonly scene;
+    constructor(target: Scene);
+    start(): Map<Image, ImageState> | null;
+    private checkAction;
+    private checkImage;
+}
+export {};

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

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

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

@@ -0,0 +1,13 @@
+import { Character, Sentence, Word } from "../elements/text";
+import { Condition, Lambda } from "../elements/condition";
+import { Control } from "../elements/control";
+import { Game } from "../game";
+import { Image } from "../elements/image";
+import { Menu } from "../elements/menu";
+import { Scene } from "../elements/scene";
+import { Script } from "../elements/script";
+import { Sound, SoundType } from "../elements/sound";
+import { Story } from "../elements/story";
+import { Transform } from "../elements/transform/transform";
+import { Utils } from "./Utils";
+export { Character, Condition, Control, Game, Image, Lambda, Menu, Scene, Script, Sentence, Sound, SoundType, Story, Transform, Utils, Word };

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

@@ -0,0 +1,3 @@
+import { LiveGame } from "../game";
+import { GameState } from "../../player/gameState";
+export { LiveGame, GameState };

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

@@ -0,0 +1,4 @@
+import Player from "../../player/elements/Player";
+import GameProviders from "../../player/provider/providers";
+import { GameState } from "../../player/gameState";
+export { GameProviders, Player, GameState, };

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

@@ -0,0 +1,2 @@
+import { Align, CommonPosition, Coord2D, CommonPositionType } from "../elements/transform/position";
+export { Align, CommonPosition, Coord2D, CommonPositionType };

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

@@ -0,0 +1,6 @@
+import { ITransition } from "../elements/transition/type";
+import { Fade } from "../elements/transition/fade";
+import { FadeIn } from "../elements/transition/fadeIn";
+import { Dissolve } from "../elements/transition/dissolve";
+export { Fade, FadeIn, Dissolve };
+export type { ITransition };

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

@@ -0,0 +1,2 @@
+import { TransformDefinitions } from "../elements/transform/type";
+export type { TransformDefinitions, };

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

@@ -0,0 +1,51 @@
+import { RenderableNode } from "../action/tree/actionTree";
+import { LogicAction } from "../action/logicAction";
+import { Actionable } from "../action/actionable";
+import { GameState } from "../../player/gameState";
+export type ConditionConfig = {};
+interface LambdaCtx {
+    gameState: GameState;
+}
+type LambdaHandler<T = any> = (ctx: LambdaCtx) => T;
+export declare class Lambda {
+    handler: LambdaHandler;
+    constructor(handler: LambdaHandler);
+    evaluate({ gameState }: {
+        gameState: GameState;
+    }): {
+        value: any;
+    };
+    getCtx({ gameState }: {
+        gameState: GameState;
+    }): LambdaCtx;
+}
+export type ConditionData = {
+    If: {
+        condition: Lambda | null;
+        action: LogicAction.Actions[] | null;
+    };
+    ElseIf: {
+        condition: Lambda | null;
+        action: (LogicAction.Actions[]) | null;
+    }[];
+    Else: {
+        action: (LogicAction.Actions[]) | null;
+    };
+};
+export declare class Condition extends Actionable {
+    static defaultConfig: ConditionConfig;
+    readonly config: ConditionConfig;
+    conditions: ConditionData;
+    constructor(config?: ConditionConfig);
+    static getInitialState(): ConditionData;
+    If(condition: Lambda | LambdaHandler<boolean>, action: LogicAction.Actions | LogicAction.Actions[]): this;
+    ElseIf(condition: Lambda | LambdaHandler<boolean>, action: (LogicAction.Actions | LogicAction.Actions[])): this;
+    Else(action: (LogicAction.Actions | LogicAction.Actions[])): this;
+    evaluate(conditions: ConditionData, { gameState }: {
+        gameState: GameState;
+    }): LogicAction.Actions[] | null;
+    toActions(): LogicAction.Actions[];
+    construct(actions: LogicAction.Actions[], lastChild?: RenderableNode, parentChild?: RenderableNode): LogicAction.Actions[];
+    _getFutureActions(): LogicAction.Actions[];
+}
+export {};

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

@@ -0,0 +1,38 @@
+import { Actionable } from "../action/actionable";
+import { LogicAction } from "../action/logicAction";
+import Actions = LogicAction.Actions;
+export declare class Control extends Actionable {
+    /**
+     * Execute actions in order, waiting for each action to complete
+     */
+    static do(actions: (Actions | Actions[])[]): Control;
+    /**
+     * Execute actions in order, do not wait for this action to complete
+     */
+    static doAsync(actions: (Actions | Actions[])[]): Control;
+    /**
+     * Execute all actions at the same time, waiting for any one action to complete
+     */
+    static any(actions: (Actions | Actions[])[]): Control;
+    /**
+     * Execute all actions at the same time, waiting for all actions to complete
+     */
+    static all(actions: (Actions | Actions[])[]): Control;
+    /**
+     * Execute all actions at the same time, do not wait for all actions to complete
+     */
+    static allAsync(actions: (Actions | Actions[])[]): Control;
+    /**
+     * Execute actions multiple times
+     */
+    static repeat(times: number, actions: (Actions | Actions[])[]): Control;
+    constructor();
+    do(actions: (Actions | Actions[])[]): this;
+    doAsync(actions: (Actions | Actions[])[]): this;
+    any(actions: (Actions | Actions[])[]): this;
+    all(actions: (Actions | Actions[])[]): this;
+    allAsync(actions: (Actions | Actions[])[]): this;
+    repeat(times: number, actions: (Actions | Actions[])[]): this;
+    construct(actions: Actions[]): Actions[];
+    private push;
+}