narraleaf-react 0.0.3 → 0.0.4

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

@@ -48,11 +48,15 @@ export declare const ImageActionTypes: {
     readonly applyTransform: "image:applyTransform";
     readonly init: "image:init";
     readonly dispose: "image:dispose";
+    /**
+     * @deprecated
+     */
     readonly setTransition: "image:setTransition";
     readonly applyTransition: "image:applyTransition";
+    readonly flush: "image:flush";
 };
 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;
+    [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] : K extends "image:flush" ? [] : any;
 };
 export declare const ConditionActionTypes: {
     readonly action: "condition:action";

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

@@ -41,6 +41,13 @@ export declare class SceneAction<T extends typeof SceneActionTypes[keyof typeof
         readonly preUnmount: "scene:preUnmount";
         readonly applyTransform: "scene:applyTransform";
     };
+    static handleSceneInit(sceneAction: SceneAction, state: GameState, awaitable: Awaitable<CalledActionResult, any>): Awaitable<CalledActionResult<any>, any> | {
+        type: number | Scene | [] | [import("../common/transition").ITransition<{}> | null] | [import("../common/transition").ITransition<{}>] | [import("../types").StaticImageData | {
+            url: string;
+        } | import("../types").color | null | undefined] | Promise<any> | Awaitable<any, any> | [Scene] | [Sound | null, (number | undefined)?] | [import("../common/elements").Transform<import("../common/types").TransformDefinitions.ImageTransformProps>];
+        node: import("../action/tree/actionTree").RenderableNode | null;
+    };
+    static registerEventListeners(scene: Scene, state: GameState, onInit?: () => void): void;
     executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
     getFutureActions(): LogicAction.Actions[];
 }
@@ -61,6 +68,7 @@ export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof
         readonly dispose: "image:dispose";
         readonly setTransition: "image:setTransition";
         readonly applyTransition: "image:applyTransition";
+        readonly flush: "image:flush";
     };
     executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
 }
@@ -70,7 +78,7 @@ export declare class ConditionAction<T extends typeof ConditionActionTypes[keyof
     };
     executeAction(gameState: GameState): {
         type: any;
-        node: ContentNode<ConditionActionContentType[T]>;
+        node: import("../action/tree/actionTree").RenderableNode | null;
     };
     getFutureActions(): LogicAction.Actions[];
 }
@@ -78,10 +86,7 @@ export declare class ScriptAction<T extends typeof ScriptActionTypes[keyof typeo
     static ActionTypes: {
         readonly action: "script:action";
     };
-    executeAction(gameState: GameState): {
-        type: any;
-        node: ContentNode<ScriptActionContentType[T]>;
-    };
+    executeAction(gameState: GameState): CalledActionResult<any> | Awaitable<CalledActionResult<any>, any>;
 }
 export declare class MenuAction<T extends typeof MenuActionTypes[keyof typeof MenuActionTypes] = typeof MenuActionTypes[keyof typeof MenuActionTypes]> extends TypedAction<MenuActionContentType, T, Menu> {
     static ActionTypes: {

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

@@ -1,11 +1,11 @@
 import { LogicAction } from "../action/logicAction";
+import { BaseElement } from "../action/baseElement";
 import Actions = LogicAction.Actions;
 import GameElement = LogicAction.GameElement;
-import { BaseElement } from "../action/baseElement";
 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 = any> {
+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[];
 }
@@ -13,5 +13,5 @@ export declare class Chained<T, Self = any> {
  * - T - the action type
  * - U - self constructor
  */
-export declare class Chainable<T, U extends Record<any, any>> extends BaseElement {
+export declare class Chainable<T, U extends Chainable<any, any>> extends BaseElement {
 }

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

@@ -23,7 +23,6 @@ export type ContentNodeData = {
 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;
-    initChild?: RenderableNode | null;
     action: LogicAction.Actions | null;
     private child?;
     private parent;
@@ -32,11 +31,6 @@ export declare class ContentNode<T = any> extends Node<T> {
     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

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

@@ -22,9 +22,11 @@ export type ImageEventTypes = {
     "event:image.applyTransform": [Transform];
     "event:image.mount": [];
     "event:image.unmount": [];
-    "event:image.ready": [React.MutableRefObject<HTMLImageElement | null>];
+    "event:image.ready": [React.MutableRefObject<HTMLDivElement | null>];
     "event:image.elementLoaded": [];
-    "event:image.setTransition": [ITransition | null];
+    "event:image.applyTransition": [ITransition];
+    "event:image.flush": [];
+    "event:image.flushComponent": [];
 };
 export declare class Image extends Actionable<ImageDataRaw, Image> {
     static EventTypes: {

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

@@ -1,11 +1,12 @@
 import { Constructable } from "../action/constructable";
 import { Awaitable, DeepPartial } from "../../../util/data";
-import { Background, CommonImage } from "../types";
+import { Background } from "../types";
 import { LogicAction } from "../action/logicAction";
 import { Transform } from "../elements/transform/transform";
 import { ITransition } from "../elements/transition/type";
 import { Sound, SoundDataRaw } from "../elements/sound";
 import { TransformDefinitions } from "../elements/transform/type";
+import { ImageDataRaw } from "../elements/image";
 import { Chained, Proxied } from "../action/chain";
 import Actions = LogicAction.Actions;
 import ImageTransformProps = TransformDefinitions.ImageTransformProps;
@@ -29,7 +30,7 @@ export type SceneDataRaw = {
         backgroundMusic?: SoundDataRaw | null;
         background?: Background["background"];
     };
-    backgroundImageState?: Partial<CommonImage>;
+    backgroundImageState?: ImageDataRaw | null;
 };
 export type SceneEventTypes = {
     "event:scene.applyTransition": [ITransition | null];

package/dist/game/nlcore/elements/transform/position.d.ts

@@ -46,6 +46,7 @@ export declare class PositionUtils {
     static D2PositionToCSS(pos: D2Position, invertX?: boolean, invertY?: boolean): CSSProps;
     static calc(pos: number | string, offset?: UnknownAble<number>): string;
     static toCoord2D(pos: IPosition | D2Position): Coord2D;
+    static orUnknown<T>(arg: T | UnknownAble<T> | undefined): T | Unknown;
     static mergePosition(a: IPosition, b: IPosition): Coord2D;
     static serializePosition(pos: IPosition): D2Position;
     static isRawCommonPositionType(arg: any): arg is CommonPositionType;
@@ -58,6 +59,7 @@ export declare class PositionUtils {
 }
 export declare class CommonPosition implements IPosition {
     static Positions: typeof CommonPositionType;
+    static isCommonPositionType(arg: any): arg is CommonPosition;
     readonly position: CommonPositionType;
     /**
      * Create a new CommonPosition instance
@@ -68,10 +70,13 @@ export declare class CommonPosition implements IPosition {
      * ```
      */
     constructor(position: CommonPositionType);
-    static isCommonPositionType(arg: any): arg is CommonPosition;
     toCSS(): D2Position;
 }
 export declare class Coord2D implements IPosition {
+    static isCoord2DPosition(arg: any): arg is Coord2D;
+    static fromCommonPosition(position: CommonPosition): Coord2D;
+    static fromAlignPosition(position: AlignPosition): Coord2D;
+    static merge(a: Coord2D, b: Coord2D): Coord2D;
     readonly x: UnknownAble<Coord2DPosition["x"]>;
     readonly y: UnknownAble<Coord2DPosition["y"]>;
     readonly xoffset: UnknownAble<number>;
@@ -92,13 +97,10 @@ export declare class Coord2D implements IPosition {
         yoffset?: UnknownAble<number>;
     });
     constructor(x: UnknownAble<Coord2DPosition["x"]>, y: UnknownAble<Coord2DPosition["y"]>);
-    static isCoord2DPosition(arg: any): arg is Coord2D;
-    static fromCommonPosition(position: CommonPosition): Coord2D;
-    static fromAlignPosition(position: AlignPosition): Coord2D;
-    static merge(a: Coord2D, b: Coord2D): Coord2D;
     toCSS(): D2Position<Coord2DPosition["x"], Coord2DPosition["y"]>;
 }
 export declare class Align implements IPosition {
+    static isAlignPosition(arg: any): arg is AlignPosition;
     readonly xalign: UnknownAble<number>;
     readonly yalign: UnknownAble<number>;
     readonly xoffset: UnknownAble<number>;
@@ -119,6 +121,5 @@ export declare class Align implements IPosition {
         xoffset?: UnknownAble<number>;
         yoffset?: UnknownAble<number>;
     });
-    static isAlignPosition(arg: any): arg is AlignPosition;
     toCSS(): D2Position;
 }

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

@@ -8,6 +8,7 @@ import { CSSProps } from "../../elements/transition/type";
 import Sequence = TransformDefinitions.Sequence;
 import SequenceProps = TransformDefinitions.SequenceProps;
 import React from "react";
+import { Image } from "../../elements/image";
 export type Transformers = "position" | "opacity" | "scale" | "rotation" | "display" | "src" | "backgroundColor" | "backgroundOpacity" | "transform";
 export type TransformHandler<T> = (value: T) => DOMKeyframesDefinition;
 export type TransformersMap = {
@@ -63,12 +64,13 @@ export declare class Transform<T extends TransformDefinitions.Types = TransformD
      * return <div ref={scope} />
      * ```
      */
-    animate({ scope, overwrites }: {
-        scope: React.MutableRefObject<HTMLImageElement | null>;
+    animate({ scope, overwrites, image }: {
+        scope: React.MutableRefObject<HTMLDivElement | null>;
         overwrites?: Partial<{
             [K in Transformers]?: TransformHandler<any>;
         }>;
-    }, gameState: GameState, initState: SequenceProps<T>, after?: (state: DeepPartial<T>) => void): Promise<void>;
+        image: Image;
+    }, gameState: GameState, initState?: SequenceProps<T>, after?: (state: DeepPartial<T>) => void): Promise<void>;
     /**
      * @example
      * ```ts

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

@@ -35,31 +35,26 @@ export declare class LiveGame {
     game: Game;
     getStorable(): Storable;
     /**
-     * Start a new game
+     * Serialize the current game state
+     *
+     * You can use this to save the game state to a file or a database
+     *
+     * Note: Even if you change just a single line of script, the saved game might not be compatible with the new version
      */
-    newGame({ gameState }: {
-        gameState: GameState;
-    }): this;
+    serialize(): SavedGame;
     /**
      * Load a saved game
      *
-     * Note: Even if you change just a single line of code, the saved game might not be compatible with the new version
+     * Note: Even if you change just a single line of script, the saved game might not be compatible with the new version
      *
      * After calling this method, the current game state will be lost, and the stage will trigger force reset
      */
-    deserialize(savedGame: SavedGame, { gameState }: {
-        gameState: GameState;
-    }): void;
+    deserialize(savedGame: SavedGame): void;
     /**
-     * Serialize the current game state
-     *
-     * You can use this to save the game state to a file or a database
-     *
-     * Note: Even if you change just a single line of code, the saved game might not be compatible with the new version
+     * Start a new game
      */
-    serialize({ gameState }: {
-        gameState: GameState;
-    }): SavedGame;
+    newGame(): this;
+    getGameState(): GameState | undefined;
 }
 declare const _default: {
     Game: typeof Game;

package/dist/game/player/elements/preload/Preload.d.ts

@@ -1,6 +1,4 @@
 import { GameState } from "../../gameState";
-import { SrcManager } from "../../../nlcore/elements/srcManager";
-export declare function Preload({ state, srcManager }: Readonly<{
+export declare function Preload({ state, }: Readonly<{
     state: GameState;
-    srcManager: SrcManager;
 }>): null;

package/dist/game/player/gameState.d.ts

@@ -44,6 +44,8 @@ type GameStateEvents = {
     "event:state.end": [];
     "event:state.player.skip": [];
     "event:state.preload.unmount": [];
+    "event:state.preload.loaded": [];
+    "event:state.player.flush": [];
 };
 export declare class GameState {
     static EventTypes: {
@@ -87,6 +89,7 @@ export declare class GameState {
     getStorable(): Storable;
     toData(): PlayerStateData;
     loadData(data: PlayerStateData, elementMap: Map<string, LogicAction.GameElement>): void;
+    initScenes(): void;
     private getElementMap;
     private removeElements;
     private _getLastSceneIfNot;

package/dist/game/player/lib/isolated.d.ts

@@ -1,5 +1,7 @@
 import React, { ReactNode } from "react";
-export default function Isolated({ children, className }: Readonly<{
+export default function Isolated({ children, className, props, ref }: Readonly<{
     children: ReactNode;
     className?: string;
+    props?: Record<any, any>;
+    ref?: React.MutableRefObject<HTMLDivElement | null>;
 }>): React.JSX.Element;