narraleaf-react 0.0.5 → 0.1.0

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

@@ -0,0 +1,40 @@
+import { LogicAction } from "../game";
+import { Color } from "../types";
+import { DeepPartial } from "../../../util/data";
+import { Actionable } from "../action/actionable";
+import { Chained, Proxied } from "../action/chain";
+import { Sentence, SentencePrompt, SentenceUserConfig } from "../elements/character/sentence";
+export type CharacterConfig = {} & Color;
+export type CharacterStateData = {
+    name: string;
+};
+export type CharacterState = {
+    name: string;
+};
+export declare class Character extends Actionable<CharacterStateData, Character> {
+    constructor(name: string | null, config?: DeepPartial<CharacterConfig>);
+    /**
+     * Say something
+     * @example
+     * ```typescript
+     * character.say("Hello, world!");
+     * ```
+     * @example
+     * ```typescript
+     * character
+     *     .say("Hello, world!")
+     *     .say("Hello, world!");
+     * ```
+     * @example
+     * ```typescript
+     * character.say(new Sentence(character, [
+     *     "Hello, ",
+     *     new Word("world", {color: "#f00"}), // Some words can be colored
+     * ]));
+     * @chainable
+     */
+    say(content: string, config?: SentenceUserConfig): Proxied<Character, Chained<LogicAction.Actions>>;
+    say(content: Sentence): Proxied<Character, Chained<LogicAction.Actions>>;
+    say(content: SentencePrompt, config?: SentenceUserConfig): Proxied<Character, Chained<LogicAction.Actions>>;
+    setName(name: string): Proxied<Character, Chained<LogicAction.Actions>>;
+}

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

@@ -33,8 +33,6 @@ export type ConditionData = {
     };
 };
 export declare class Condition extends Actionable {
-    static defaultConfig: ConditionConfig;
-    static getInitialState(): ConditionData;
     constructor(config?: ConditionConfig);
     /**
      * @chainable

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

@@ -1,5 +1,6 @@
 import { Actionable } from "../action/actionable";
 import { LogicAction } from "../action/logicAction";
+import { Awaitable } from "../../../util/data";
 import { Chained, ChainedActions, Proxied } from "../action/chain";
 type ChainedControl = Proxied<Control, Chained<LogicAction.Actions>>;
 export declare class Control extends Actionable {
@@ -33,6 +34,11 @@ export declare class Control extends Actionable {
      * @chainable
      */
     static repeat(times: number, actions: ChainedActions): ChainedControl;
+    /**
+     * Sleep for a duration
+     * @chainable
+     */
+    static sleep(duration: number | Awaitable<any> | Promise<any>): ChainedControl;
     constructor();
     /**
      * Execute actions in order, waiting for each action to complete
@@ -64,5 +70,10 @@ export declare class Control extends Actionable {
      * @chainable
      */
     repeat(times: number, actions: ChainedActions): ChainedControl;
+    /**
+     * Sleep for a duration
+     * @chainable
+     */
+    sleep(duration: number | Awaitable<any> | Promise<any>): ChainedControl;
 }
 export {};

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

@@ -2,44 +2,32 @@ import React from "react";
 import type { TransformDefinitions } from "../elements/transform/type";
 import { Actionable } from "../action/actionable";
 import { Transform } from "./transform/transform";
-import { CommonImage, StaticImageData } from "../types";
+import { CommonDisplayable, EventfulDisplayable, StaticImageData } from "../types";
 import { LogicAction } from "../game";
-import { ITransition } from "../elements/transition/type";
+import { IImageTransition, ITransition } from "../elements/transition/type";
 import { DeepPartial } from "../../../util/data";
 import { Chained, Proxied } from "../action/chain";
 export type ImageConfig = {
     src: string | StaticImageData;
     display: boolean;
     disposed?: boolean;
-} & CommonImage;
+} & CommonDisplayable;
 export type ImageDataRaw = {
     state: Record<string, any>;
 };
 export type ImageEventTypes = {
-    "event:image.show": [Transform];
-    "event:image.hide": [Transform];
     "event:image.init": [];
-    "event:image.applyTransform": [Transform];
     "event:image.mount": [];
     "event:image.unmount": [];
     "event:image.ready": [React.MutableRefObject<HTMLDivElement | null>];
     "event:image.elementLoaded": [];
-    "event:image.applyTransition": [ITransition];
     "event:image.flush": [];
     "event:image.flushComponent": [];
+    "event:displayable.applyTransition": [ITransition];
+    "event:displayable.applyTransform": [Transform];
+    "event:displayable.init": [];
 };
-export declare class Image extends Actionable<ImageDataRaw, Image> {
-    static EventTypes: {
-        [K in keyof ImageEventTypes]: K;
-    };
-    static defaultConfig: ImageConfig;
-    static ImagePosition: {
-        center: "center";
-        left: "left";
-        right: "right";
-    };
-    static serializeImageState(state: Record<string, any>): Record<string, any>;
-    static deserializeImageState(state: Record<string, any>): ImageConfig;
+export declare class Image extends Actionable<ImageDataRaw, Image> implements EventfulDisplayable {
     constructor(name: string, config: DeepPartial<ImageConfig>);
     constructor(config: DeepPartial<ImageConfig>);
     /**
@@ -64,7 +52,7 @@ export declare class Image extends Actionable<ImageDataRaw, Image> {
      * ```
      * @chainable
      */
-    setSrc(src: string | StaticImageData, transition?: ITransition): Proxied<Image, Chained<LogicAction.Actions>>;
+    setSrc(src: string | StaticImageData, transition?: IImageTransition): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Apply a transform to the image
      * @example
@@ -98,7 +86,7 @@ export declare class Image extends Actionable<ImageDataRaw, Image> {
      * ```
      * @chainable
      */
-    applyTransform(transform: Transform): Proxied<Image, Chained<LogicAction.Actions>>;
+    applyTransform(transform: Transform<TransformDefinitions.ImageTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Show the image
      *
@@ -112,14 +100,14 @@ export declare class Image extends Actionable<ImageDataRaw, Image> {
      * @chainable
      */
     show(): Proxied<Image, Chained<LogicAction.Actions>>;
-    show(options: Transform): Proxied<Image, Chained<LogicAction.Actions>>;
+    show(options: Transform<TransformDefinitions.ImageTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     show(options: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Hide the image
      * @chainable
      */
     hide(): Proxied<Image, Chained<LogicAction.Actions>>;
-    hide(transform: Transform): Proxied<Image, Chained<LogicAction.Actions>>;
+    hide(transform: Transform<TransformDefinitions.ImageTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     hide(transform: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     copy(): Image;
 }

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

@@ -1,18 +1,16 @@
-import { Sentence, Word } from "./text";
 import { LogicAction } from "../action/logicAction";
-import { MenuAction } from "../action/actions";
 import { Actionable } from "../action/actionable";
 import { Chained, Proxied } from "../action/chain";
+import { Sentence, SentencePrompt } from "../elements/character/sentence";
 import Actions = LogicAction.Actions;
 import GameElement = LogicAction.GameElement;
 export type MenuConfig = {};
 export type MenuChoice = {
     action: ChainedActions;
-    prompt: UnSentencePrompt | Sentence;
+    prompt: SentencePrompt | Sentence;
 };
 type ChainedAction = Proxied<GameElement, Chained<LogicAction.Actions>>;
 type ChainedActions = (ChainedAction | ChainedAction[] | Actions | Actions[])[];
-type UnSentencePrompt = (string | Word)[] | (string | Word);
 export type Choice = {
     action: Actions[];
     prompt: Sentence;
@@ -22,9 +20,7 @@ export type MenuData = {
     choices: Choice[];
 };
 export declare class Menu extends Actionable<any, Menu> {
-    static defaultConfig: MenuConfig;
-    static targetAction: typeof MenuAction;
-    constructor(prompt: UnSentencePrompt, config?: MenuConfig);
+    constructor(prompt: SentencePrompt, config?: MenuConfig);
     constructor(prompt: Sentence, config?: MenuConfig);
     /**
      * Add a choice to the menu
@@ -36,6 +32,6 @@ export declare class Menu extends Actionable<any, Menu> {
      */
     choose(choice: MenuChoice): Proxied<Menu, Chained<LogicAction.Actions>>;
     choose(prompt: Sentence, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
-    choose(prompt: UnSentencePrompt, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
+    choose(prompt: SentencePrompt, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
 }
 export {};

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

@@ -1,27 +1,37 @@
 import { Constructable } from "../action/constructable";
-import { Awaitable, DeepPartial } from "../../../util/data";
-import { Background } from "../types";
+import { Awaitable } from "../../../util/data";
+import { Background, EventfulDisplayable, ImageColor, ImageSrc } from "../types";
 import { LogicAction } from "../action/logicAction";
 import { Transform } from "../elements/transform/transform";
-import { ITransition } from "../elements/transition/type";
+import { IImageTransition, ITransition } from "../elements/transition/type";
 import { Sound, SoundDataRaw } from "../elements/sound";
 import { TransformDefinitions } from "../elements/transform/type";
-import { ImageDataRaw } from "../elements/image";
+import { Image, ImageDataRaw } from "../elements/image";
 import { Chained, Proxied } from "../action/chain";
+import { RGBColor } from "../common/Utils";
 import Actions = LogicAction.Actions;
 import ImageTransformProps = TransformDefinitions.ImageTransformProps;
 import GameElement = LogicAction.GameElement;
+export type UserImageInput = ImageSrc | RGBColor | ImageColor;
 export type SceneConfig = {
     invertY: boolean;
     invertX: boolean;
     backgroundMusic: Sound | null;
     backgroundMusicFade: number;
-} & Background;
-export type SceneState = {
-    backgroundMusic?: Sound | null;
+    backgroundImage: Image;
+} & {
+    background: ImageSrc | ImageColor | null;
 };
+export interface ISceneConfig {
+    invertY: boolean;
+    invertX: boolean;
+    backgroundMusic: Sound | null;
+    backgroundMusicFade: number;
+    background?: ImageSrc | ImageColor;
+}
+export type SceneState = {};
 export type JumpConfig = {
-    transition: ITransition;
+    transition: IImageTransition;
 };
 type ChainableAction = Proxied<GameElement, Chained<LogicAction.Actions>> | Actions;
 type ChainedScene = Proxied<Scene, Chained<LogicAction.Actions>>;
@@ -33,7 +43,6 @@ export type SceneDataRaw = {
     backgroundImageState?: ImageDataRaw | null;
 };
 export type SceneEventTypes = {
-    "event:scene.applyTransition": [ITransition | null];
     "event:scene.remove": [];
     "event:scene.load": [];
     "event:scene.unload": [];
@@ -41,17 +50,13 @@ export type SceneEventTypes = {
     "event:scene.unmount": [];
     "event:scene.preUnmount": [];
     "event:scene.imageLoaded": [];
-    "event:scene.initTransform": [Transform<ImageTransformProps>];
     "event:scene.setBackgroundMusic": [Sound | null, number];
-    "event:scene.applyTransform": [Transform<ImageTransformProps>];
+    "event:displayable.applyTransition": [ITransition];
+    "event:displayable.applyTransform": [Transform];
+    "event:displayable.init": [];
 };
-export declare class Scene extends Constructable<Actions, Scene> {
-    static EventTypes: {
-        [K in keyof SceneEventTypes]: K;
-    };
-    static defaultConfig: SceneConfig;
-    static defaultState: SceneState;
-    constructor(name: string, config?: DeepPartial<SceneConfig>);
+export declare class Scene extends Constructable<Actions, Scene> implements EventfulDisplayable {
+    constructor(name: string, config?: Partial<ISceneConfig>);
     /**
      * Activate the scene
      *
@@ -70,7 +75,7 @@ export declare class Scene extends Constructable<Actions, Scene> {
      * Set background, if {@link transition} is provided, it will be applied
      * @chainable
      */
-    setBackground(background: Background["background"], transition?: ITransition): ChainedScene;
+    setBackground(background: UserImageInput, transition?: IImageTransition): ChainedScene;
     /**
      * Apply a transform to the scene
      *

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

@@ -34,8 +34,8 @@ export type SoundConfig = {
     streaming?: boolean;
 };
 export declare class Sound extends Actionable<SoundDataRaw> {
-    static defaultConfig: SoundConfig;
     constructor(config?: DeepPartial<SoundConfig>);
+    constructor(src?: string);
     /**
      * @chainable
      */

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

@@ -1,6 +1,6 @@
 import { Constructable } from "../action/constructable";
-import { SceneAction } from "../action/actions";
 import { Scene } from "../elements/scene";
+import { SceneAction } from "../action/actions/sceneAction";
 export type StoryConfig = {};
 export type ElementStateRaw = Record<string, any>;
 export type NodeChildIdMap = Map<string, string>;

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

@@ -1,68 +1,80 @@
-import { LogicAction } from "../game";
-import { color, Color } from "../types";
-import { DeepPartial } from "../../../util/data";
+import { color, CommonDisplayable, EventfulDisplayable } from "../types";
 import { Actionable } from "../action/actionable";
-import type { Sound } from "../elements/sound";
 import { Chained, Proxied } from "../action/chain";
-export type SentenceConfig = {
-    pause?: boolean | number;
-    voice: Sound | string | null | undefined;
-} & Color;
-export type WordConfig = {} & Color;
-export type SentenceDataRaw = {
-    state: SentenceState;
-};
-export type SentenceState = {
+import { LogicAction } from "../action/logicAction";
+import { Transform } from "../elements/transform/transform";
+import type { TransformDefinitions } from "../elements/transform/type";
+import { ITextTransition, ITransition } from "../elements/transition/type";
+export type TextConfig = {
+    alignX: "left" | "center" | "right";
+    alignY: "top" | "center" | "bottom";
+    className?: string;
+    fontSize: number;
+    fontColor: color;
     display: boolean;
+    text: string;
+} & CommonDisplayable;
+export type TextDataRaw = {
+    state: Record<string, any>;
 };
-type UnSentencePrompt = (string | Word)[] | (string | Word);
-export declare class Sentence {
-    static defaultConfig: SentenceConfig;
-    static defaultState: SentenceState;
-    static isSentence(obj: any): obj is Sentence;
-    static toSentence(prompt: UnSentencePrompt | Sentence): Sentence;
-    constructor(character: Character | null, text: (string | Word)[] | (string | Word), config?: Partial<SentenceConfig>);
-}
-export declare class Word {
-    static defaultConfig: Partial<WordConfig>;
-    static defaultColor: color;
-    static isWord(obj: any): obj is Word;
-    constructor(text: string, config?: Partial<WordConfig>);
-}
-export declare enum CharacterMode {
-    "adv" = "adv",
-    "nvl" = "nvl"
-}
-export type CharacterConfig = {
-    mode: CharacterMode;
+export type TextEventTypes = {
+    "event:text.show": [Transform];
+    "event:text.hide": [Transform];
+    "event:displayable.applyTransition": [ITransition];
+    "event:displayable.applyTransform": [Transform];
+    "event:displayable.init": [];
 };
-export type CharacterStateData = {};
-export declare class Character extends Actionable<CharacterStateData, Character> {
-    static Modes: typeof CharacterMode;
-    static defaultConfig: CharacterConfig;
-    constructor(name: string | null, config?: DeepPartial<CharacterConfig>);
+export declare class Text extends Actionable<TextDataRaw, Text> implements EventfulDisplayable {
+    constructor(config: Partial<TextConfig>);
+    constructor(text: string, config?: Partial<TextConfig>);
+    /**
+     * Apply a transform to the Text
+     * @chainable
+     */
+    applyTransform(transform: Transform<TransformDefinitions.TextTransformProps>): Proxied<Text, Chained<LogicAction.Actions>>;
+    /**
+     * Apply a transition to the Text
+     * @chainable
+     */
+    applyTransition(transition: ITextTransition): Proxied<Text, Chained<LogicAction.Actions>>;
     /**
-     * Say something
+     * Show the Text
+     *
+     * if options is provided, the text will show with the provided transform options
      * @example
-     * ```typescript
-     * character.say("Hello, world!");
+     * ```ts
+     * text.show({
+     *     duration: 1000,
+     * });
      * ```
+     * @chainable
+     */
+    show(): Proxied<Text, Chained<LogicAction.Actions>>;
+    show(options: Transform<TransformDefinitions.TextTransformProps>): Proxied<Text, Chained<LogicAction.Actions>>;
+    show(options: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Text, Chained<LogicAction.Actions>>;
+    /**
+     * Hide the Text
+     *
+     * if options is provided, the text will hide with the provided transform options
      * @example
-     * ```typescript
-     * character
-     *     .say("Hello, world!")
-     *     .say("Hello, world!");
+     * ```ts
+     * text.hide({
+     *     duration: 1000,
+     * });
      * ```
-     * @example
-     * ```typescript
-     * character.say(new Sentence(character, [
-     *     "Hello, ",
-     *     new Word("world", {color: "#f00"}), // Some words can be colored
-     * ]));
      * @chainable
      */
-    say(content: string): Proxied<Character, Chained<LogicAction.Actions>>;
-    say(content: Sentence): Proxied<Character, Chained<LogicAction.Actions>>;
-    say(content: (string | Word)[]): Proxied<Character, Chained<LogicAction.Actions>>;
+    hide(): Proxied<Text, Chained<LogicAction.Actions>>;
+    hide(options: Transform<TransformDefinitions.TextTransformProps>): Proxied<Text, Chained<LogicAction.Actions>>;
+    hide(options: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Text, Chained<LogicAction.Actions>>;
+    /**
+     * Set the text of the Text
+     * @chainable
+     */
+    setText(text: string): Proxied<Text, Chained<LogicAction.Actions>>;
+    /**
+     * Set the font color of the Text
+     * @chainable
+     */
+    setFontSize(fontSize: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Text, Chained<LogicAction.Actions>>;
 }
-export {};

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

@@ -15,11 +15,11 @@ export interface IPosition {
 export type Coord2DPosition = {
     x: number | `${"-" | ""}${number}%`;
     y: number | `${"-" | ""}${number}%`;
-} & OffsetPosition;
+} & Partial<OffsetPosition>;
 export type AlignPosition = {
     xalign: number;
     yalign: number;
-} & OffsetPosition;
+} & Partial<OffsetPosition>;
 export type OffsetPosition = {
     xoffset: number;
     yoffset: number;
@@ -52,7 +52,7 @@ export declare class PositionUtils {
     static isRawCommonPositionType(arg: any): arg is CommonPositionType;
     static isRawCoord2DPosition(arg: any): arg is Coord2DPosition;
     static isRawAlignPosition(arg: any): arg is AlignPosition;
-    static isRawPosition(arg: any): arg is IPosition;
+    static isRawPosition(arg: any): arg is RawPosition;
     static isPosition(arg: any): arg is IPosition;
     static rawPositionToCoord2D(arg: any): Coord2D;
     static tryParsePosition(arg: any): IPosition;

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

@@ -1,18 +1,12 @@
-import type { Background, CommonImage, CommonImagePosition } from "../../types";
-import type { AnimationPlaybackControls, DOMKeyframesDefinition, DynamicAnimationOptions } from "framer-motion";
-import { DeepPartial } from "../../../../util/data";
-import { GameState } from "../../../player/gameState";
+import type { Background, color, CommonDisplayable } from "../../types";
+import type { DOMKeyframesDefinition } from "framer-motion";
 import { TransformDefinitions } from "./type";
-import { Align, Coord2D, IPosition, RawPosition } from "./position";
-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 Transformers = "position" | "opacity" | "scale" | "rotation" | "display" | "src" | "backgroundColor" | "backgroundOpacity" | "transform" | "fontSize" | "fontColor";
 export type TransformHandler<T> = (value: T) => DOMKeyframesDefinition;
 export type TransformersMap = {
-    "position": CommonImage["position"];
+    "position": CommonDisplayable["position"];
     "opacity": number;
     "scale": number;
     "rotation": number;
@@ -21,19 +15,10 @@ export type TransformersMap = {
     "backgroundColor": Background["background"];
     "backgroundOpacity": number;
     "transform": TransformDefinitions.Types;
+    "fontSize": number;
+    "fontColor": color;
 };
-export declare class Transform<T extends TransformDefinitions.Types = TransformDefinitions.ImageTransformProps> {
-    static defaultSequenceOptions: Partial<TransformDefinitions.CommonSequenceProps>;
-    static defaultOptions: TransformDefinitions.SequenceProps<any>;
-    static CommonImagePositionMap: {
-        readonly left: "25.33%";
-        readonly center: "50%";
-        readonly right: "75.66%";
-    };
-    private readonly sequenceOptions;
-    private sequences;
-    private control;
-    private transformers;
+export declare class Transform<T extends TransformDefinitions.Types = object> {
     /**
      * @example
      * ```ts
@@ -46,31 +31,8 @@ export declare class Transform<T extends TransformDefinitions.Types = TransformD
      * });
      * ```
      */
-    constructor(sequences: Sequence<T>[], sequenceOptions?: Partial<TransformDefinitions.TransformConfig>);
+    constructor(sequences: Sequence<T>[], transformConfig?: Partial<TransformDefinitions.TransformConfig>);
     constructor(props: SequenceProps<T>, options?: Partial<TransformDefinitions.CommonTransformProps>);
-    static isPosition(position: any): position is (CommonImagePosition | Coord2D | Align);
-    static positionToCSS(position: IPosition, invertY?: boolean | undefined, invertX?: boolean | undefined): CSSProps;
-    static backgroundToCSS(background: Background["background"]): {
-        backgroundImage?: string;
-        backgroundColor?: string;
-    };
-    static mergePosition(a: RawPosition | undefined, b: RawPosition | undefined): Coord2D;
-    static mergeState<T>(state: any, props: any): DeepPartial<T>;
-    /**
-     * @example
-     * ```ts
-     * const [scope, animate] = useAnimation();
-     * transform.animate(scope, animate);
-     * return <div ref={scope} />
-     * ```
-     */
-    animate({ scope, overwrites, image }: {
-        scope: React.MutableRefObject<HTMLDivElement | null>;
-        overwrites?: Partial<{
-            [K in Transformers]?: TransformHandler<any>;
-        }>;
-        image: Image;
-    }, gameState: GameState, initState?: SequenceProps<T>, after?: (state: DeepPartial<T>) => void): Promise<void>;
     /**
      * @example
      * ```ts
@@ -93,12 +55,5 @@ export declare class Transform<T extends TransformDefinitions.Types = TransformD
      * ```
      */
     overwrite<T extends keyof TransformersMap = any>(key: T, transformer: TransformHandler<TransformersMap[T]>): this;
-    propToCSS(state: GameState, prop: DeepPartial<T>, overwrites?: Partial<{
-        [K in Transformers]?: TransformHandler<any>;
-    }>): DOMKeyframesDefinition;
-    optionsToFramerMotionOptions(options?: Partial<TransformDefinitions.CommonTransformProps>): DynamicAnimationOptions | void;
-    propToCSSTransform(state: GameState, prop: Record<string, any>): string;
-    setControl(control: AnimationPlaybackControls | null): this;
-    getControl(): AnimationPlaybackControls | null;
     copy(): Transform<T>;
 }

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

@@ -1,4 +1,4 @@
-import { Background, CommonImage } from "../../types";
+import { color, CommonDisplayable } from "../../types";
 import { DeepPartial } from "../../../../util/data";
 import type { AnimationPlaybackControls, AnimationScope, AnimationSequence, DOMKeyframesDefinition, DynamicAnimationOptions, ElementOrSelector, MotionValue, ValueAnimationTransition } from "framer-motion";
 export declare namespace TransformDefinitions {
@@ -27,15 +27,14 @@ export declare namespace TransformDefinitions {
         sync: boolean;
         repeat: number;
     };
-    type SceneBackgroundTransformProps = {
-        background: Background["background"];
-        backgroundOpacity: number;
-    };
-    type ImageTransformProps = CommonImage & {
+    type ImageTransformProps = CommonDisplayable & {
         display: boolean;
-        position: CommonImage["position"];
+        position: CommonDisplayable["position"];
+    };
+    type TextTransformProps = ImageTransformProps & {
+        fontColor: color;
     };
-    type Types = ImageTransformProps | SceneBackgroundTransformProps;
+    type Types = ImageTransformProps | TextTransformProps | object;
     type SequenceProps<T> = DeepPartial<T>;
     type SequenceOptions = Partial<CommonTransformProps>;
     type Sequence<T> = {

package/dist/game/nlcore/elements/transition/{base.d.ts → baseTransitions.d.ts}

@@ -1,12 +1,13 @@
 import { EventDispatcher } from "../../../../util/data";
-import { ElementProp, EventTypes, ITransition } from "./type";
+import { ElementProp, EventTypes, IImageTransition, ITransition } from "./type";
 import type { AnimationPlaybackControls, ValueAnimationTransition } from "framer-motion";
-export declare class Base<T extends ElementProp> implements ITransition<T> {
+import { ImageColor, ImageSrc } from "../../types";
+export declare class BaseTransition<T extends ElementProp> implements ITransition<T> {
     controller: AnimationPlaybackControls | null | undefined;
     events: EventDispatcher<EventTypes<[T[]]>>;
     start(_onComplete?: () => void): void;
     toElementProps(): T[];
-    setSrc(_src: string): void;
+    copy(): ITransition<T>;
     protected requestAnimation({ start, end, duration }: {
         start: number;
         end: number;
@@ -15,5 +16,11 @@ export declare class Base<T extends ElementProp> implements ITransition<T> {
         onComplete?: () => void;
         onUpdate?: (value: number) => void;
     }, options?: ValueAnimationTransition<number>): AnimationPlaybackControls;
+}
+export declare class BaseImageTransition<T extends ElementProp> extends BaseTransition<T> implements IImageTransition<T> {
+    setSrc(_src?: ImageSrc | ImageColor): this;
+    copy(): IImageTransition<T>;
+}
+export declare class BaseTextTransition<T extends ElementProp> extends BaseTransition<T> implements ITransition<T> {
     copy(): ITransition<T>;
 }

package/dist/game/nlcore/elements/transition/imageTransitions/dissolve.d.ts

@@ -0,0 +1,25 @@
+import { IImageTransition, ImgElementProp } from "../type";
+import { BaseImageTransition } from "../baseTransitions";
+import { ImageColor, ImageSrc } from "../../../types";
+import { TransformDefinitions } from "../../../elements/transform/type";
+/**
+ * @class Dissolve
+ * @implements ITransition
+ * @extends BaseTransition
+ * @description Dissolve transition effect
+ */
+export declare class Dissolve extends BaseImageTransition<ImgElementProp> implements IImageTransition {
+    static Frames: [number, number];
+    private readonly duration;
+    private state;
+    private src?;
+    private readonly easing;
+    /**
+     * Image will dissolve from one image to another
+     */
+    constructor(duration?: number, easing?: TransformDefinitions.EasingDefinition);
+    setSrc(src: ImageSrc | ImageColor | undefined): this;
+    start(onComplete?: () => void): void;
+    toElementProps(): ImgElementProp[];
+    copy(): Dissolve;
+}