narraleaf-react 0.0.1-beta.1 → 0.0.1-beta.10

package/README.md

@@ -0,0 +1,123 @@
+![](./docs/nlr-logo-banner.png)
+
+# NarraLeaf-React
+
+A React visual novel player framework
+
+## What is NarraLeaf-React?
+
+NarraLeaf-React is a lightweight front-end visual novel player.  
+NL focuses on visual novel playing, so the user interface can be customized very easily.
+
+It doesn't use any rendering libraries and can be used on any web platform (e.g. Electron)
+
+## Why NarraLeaf-React?
+
+- **Lightweight**: NarraLeaf-React is a front-end framework, and it doesn't use any rendering libraries.
+- **Customizable**: You can customize the UI as you like, even replace the whole components.
+- **Easy to use**: It is easy to use and has a simple API that is built for developers. Based on OOP principles.
+- **Built for React**: It is built for React!
+- **Cross-platform**: It can be used on any web platform (e.g. Electron)
+
+## Get Started
+
+### Install
+
+```bash
+npm install narraleaf-react
+```
+
+### Documentation
+
+- [Quick Start](./docs/quick-start.md)
+- [Customization](./docs/customization.md)
+
+Read more in [🛠React.NarraLeaf.com](https://react.narraleaf.com)
+
+### Example
+
+```tsx
+"use client";
+
+import {Character, Scene, Story, Image, Player, GameProviders} from "narraleaf-react";
+
+export default function App() {
+
+    const character1 = new Character("character1");
+    const image1 = new Image({
+        src: "https://placehold.it/200x200",
+    })
+
+    const story = new Story("My First NarraLeaf Story").entry(
+        new Scene("scene1").action([
+            // Show image1 for 1 second
+            image1.show({
+                duration: 1000,
+            }).toActions(),
+
+            // Say something
+            character1
+                .say("Hello, world!")
+                .say("This is my first NarraLeaf story.")
+                .say("Start editing this file and enjoy the journey!")
+                .toActions(),
+        ])
+    );
+
+    function handleOnReady({game}) {
+        game.getLiveGame().newGame();
+    }
+
+    return (
+        <GameProviders>
+            <Player
+                story={story}
+                onReady={handleOnReady}
+                width="100vw"
+                height="100vh"
+            />
+        </GameProviders>
+    );
+}
+```
+
+Read more in [Quick Start](./docs/quick-start.md)
+
+### Performance
+
+Please enable image cache for a better performance.  
+Narraleaf-React tries to cache the images before showing them, but it is recommended to enable cache on your server.
+
+for NextJS, add this to your `next.config.js`:
+
+```js
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+        async headers() {
+            return [
+                {
+                    source: '/YOUR_IMAGE_ENDPOINT/(.*)', // ex: /static/images/(.*)
+                    headers: [
+                        {
+                            key: 'Cache-Control',
+                            value: 'public, max-age=31536000, immutable',
+                        },
+                    ],
+                }
+            ]
+        }
+    };
+
+export default nextConfig;
+```
+
+## License
+
+> NarraLeaf-React is licensed under the MIT License.
+
+## Contributing
+
+We welcome all contributions.  
+If you have any ideas, just open an issue or a pull request.
+
+

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

@@ -1,6 +1,6 @@
 import { LogicAction } from "./logicAction";
 import { ContentNode } from "../action/tree/actionTree";
-import type { CalledActionResult } from "@core/gameTypes";
+import type { CalledActionResult } from "../gameTypes";
 import { Awaitable } from "../../../util/data";
 import { GameState } from "../../player/gameState";
 export declare class Action<ContentNodeType = any, Callee = LogicAction.GameElement> {

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

@@ -79,15 +79,17 @@ export declare const SoundActionTypes: {
     readonly fade: "sound:fade";
     readonly setVolume: "sound:setVolume";
     readonly setRate: "sound:setRate";
+    readonly pause: "sound:pause";
+    readonly resume: "sound:resume";
 };
 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;
+            start?: number;
             end: number;
             duration: number;
         }
-    ] : K extends "sound:setVolume" ? [number] : K extends "sound:setRate" ? [number] : any;
+    ] : K extends "sound:setVolume" ? [number] : K extends "sound:setRate" ? [number] : K extends "sound:pause" ? [void] : K extends "sound:resume" ? [void] : any;
 };
 export declare const ControlActionTypes: {
     readonly action: "control:action";

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

@@ -9,7 +9,7 @@ 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 type { CalledActionResult } from "../gameTypes";
 import { GameState } from "../../player/gameState";
 import type { Sound } from "../elements/sound";
 import { Control } from "../elements/control";
@@ -97,6 +97,8 @@ export declare class SoundAction<T extends typeof SoundActionTypes[keyof typeof
         readonly fade: "sound:fade";
         readonly setVolume: "sound:setVolume";
         readonly setRate: "sound:setRate";
+        readonly pause: "sound:pause";
+        readonly resume: "sound:resume";
     };
     static initSound(state: GameState, sound: Sound): void;
     executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;

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

@@ -1,4 +1,7 @@
 import Player from "../../player/elements/Player";
 import GameProviders from "../../player/provider/providers";
 import { GameState } from "../../player/gameState";
-export { GameProviders, Player, GameState, };
+import { useGame } from "../../../game/player/provider/game-state";
+export * from "../../player/type";
+export * from "../../player/libElements";
+export { GameProviders, Player, useGame, GameState, };

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

@@ -2,5 +2,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 };
+import { Base } from "../elements/transition/base";
+export { Fade, FadeIn, Dissolve, Base };
 export type { ITransition };

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

@@ -1,14 +1,13 @@
-import { CommonImage, NextJSStaticImageData, StaticImageData } from "../types";
-import { DeepPartial, EventDispatcher } from "../../../util/data";
-import { Transform } from "./transform/transform";
+import React from "react";
+import type { TransformDefinitions } from "../elements/transform/type";
 import { ImageAction } from "../action/actions";
 import { Actionable } from "../action/actionable";
-import type { TransformDefinitions } from "../elements/transform/type";
-import React from "react";
-import { AnimationScope } from "framer-motion";
+import { Transform } from "./transform/transform";
+import { CommonImage, StaticImageData } from "../types";
 import { ITransition } from "../elements/transition/type";
+import { DeepPartial, EventDispatcher } from "../../../util/data";
 export type ImageConfig = {
-    src: string | NextJSStaticImageData;
+    src: string | StaticImageData;
     display: boolean;
     disposed?: boolean;
 } & CommonImage;
@@ -22,7 +21,7 @@ export type ImageEventTypes = {
     "event:image.applyTransform": [Transform];
     "event:image.mount": [];
     "event:image.unmount": [];
-    "event:image.ready": [AnimationScope];
+    "event:image.ready": [React.MutableRefObject<HTMLImageElement | null>];
     "event:image.elementLoaded": [];
     "event:image.setTransition": [ITransition | null];
 };
@@ -69,6 +68,7 @@ export declare class Image extends Actionable<ImageDataRaw> {
      * @example
      * ```ts
      * // shake the image
+     *
      * image.applyTransform(
      *     new Transform([
      *         {
@@ -117,7 +117,6 @@ export declare class Image extends Actionable<ImageDataRaw> {
     hide(transform: Transform): this;
     hide(transform: Partial<TransformDefinitions.CommonTransformProps>): this;
     toTransform(): Transform;
-    toHTMLElementProps(): React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>;
     setScope(scope: React.RefObject<HTMLImageElement>): this;
     getScope(): React.RefObject<HTMLImageElement> | undefined;
     copy(): Image;

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

@@ -81,7 +81,7 @@ export declare class Scene extends Constructable<any, Actions, SceneAction<"scen
      *
      * Any operations after the jump operation will not be executed
      */
-    jumpTo(arg0: Scene, config?: JumpConfig): this;
+    jumpTo(arg0: Scene, config?: Partial<JumpConfig>): this;
     transitionSceneBackground(scene?: Scene, transition?: ITransition): this;
     /**
      * Wait for a period of time, the parameter can be the number of milliseconds, a Promise, or an unresolved {@link Awaitable}

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

@@ -42,9 +42,11 @@ export declare class Sound extends Actionable<SoundDataRaw> {
     constructor(config?: DeepPartial<SoundConfig>);
     play(): this;
     stop(): this;
-    fade(start: number, end: number, duration: number): this;
+    fade(start: number | undefined, end: number, duration: number): this;
     setVolume(volume: number): this;
     setRate(rate: number): this;
+    pause(fade?: number): this;
+    resume(fade?: number): this;
     getHowlOptions(): HowlOptions;
     getSrc(): string;
     $setToken(token: any): void;

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

@@ -1,7 +1,10 @@
-import { Color } from "../types";
+import { color, Color } from "../types";
+import { DeepPartial } from "../../../util/data";
 import { Actionable } from "../action/actionable";
+import type { Sound } from "../elements/sound";
 export type SentenceConfig = {
     pause?: boolean | number;
+    voice: Sound | string | null | undefined;
 } & Color;
 export type WordConfig = {} & Color;
 export type SentenceDataRaw = {
@@ -28,18 +31,27 @@ export declare class Sentence {
     toString(): string;
 }
 export declare class Word {
-    static defaultConfig: WordConfig;
+    static defaultConfig: Partial<WordConfig>;
+    static defaultColor: color;
     text: string;
-    config: WordConfig;
+    config: Partial<WordConfig>;
     constructor(text: string, config?: Partial<WordConfig>);
     static isWord(obj: any): obj is Word;
 }
-export type CharacterConfig = {};
+export declare enum CharacterMode {
+    "adv" = "adv",
+    "nvl" = "nvl"
+}
+export type CharacterConfig = {
+    mode: CharacterMode;
+};
 export type CharacterStateData = {};
 export declare class Character extends Actionable<CharacterStateData> {
+    static Modes: typeof CharacterMode;
+    static defaultConfig: CharacterConfig;
     name: string | null;
     config: CharacterConfig;
-    constructor(name: string | null, config?: CharacterConfig);
+    constructor(name: string | null, config?: DeepPartial<CharacterConfig>);
     /**
      * Say something
      * @example

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

@@ -1,13 +1,13 @@
 import { CSSProps } from "../../elements/transition/type";
 export declare enum CommonPositionType {
-    Left = 0,
-    Center = 1,
-    Right = 2
+    Left = "left",
+    Center = "center",
+    Right = "right"
 }
 export declare const CommonPositions: {
-    0: `${number}%`;
-    1: `${number}%`;
-    2: `${number}%`;
+    left: `${number}%`;
+    center: `${number}%`;
+    right: `${number}%`;
 };
 export interface IPosition {
     toCSS(): D2Position;
@@ -30,6 +30,13 @@ export type D2Position<X = any, Y = any> = {
     xoffset: UnknownAble<number>;
     yoffset: UnknownAble<number>;
 };
+export type RawPosition = CommonPositionType | (Coord2DPosition & {
+    xalign?: never;
+    yalign?: never;
+}) | (AlignPosition & {
+    x: never;
+    y: never;
+});
 export type Unknown = typeof PositionUtils.Unknown;
 export type UnknownAble<T> = T | Unknown;
 export declare class PositionUtils {
@@ -41,6 +48,13 @@ export declare class PositionUtils {
     static toCoord2D(pos: IPosition | D2Position): Coord2D;
     static mergePosition(a: IPosition, b: IPosition): Coord2D;
     static serializePosition(pos: IPosition): D2Position;
+    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 isPosition(arg: any): arg is IPosition;
+    static rawPositionToCoord2D(arg: any): Coord2D;
+    static tryParsePosition(arg: any): IPosition;
 }
 export declare class CommonPosition implements IPosition {
     static Positions: typeof CommonPositionType;
@@ -50,10 +64,10 @@ export declare class CommonPosition implements IPosition {
      * @example
      * ```ts
      * new CommonPosition(CommonPosition.Positions.Center);
-     * new CommonPosition("Center");
+     * new CommonPosition("center");
      * ```
      */
-    constructor(position: CommonPositionType | keyof typeof CommonPositionType);
+    constructor(position: CommonPositionType);
     static isCommonPositionType(arg: any): arg is CommonPosition;
     toCSS(): D2Position;
 }

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

@@ -3,10 +3,11 @@ import type { AnimationPlaybackControls, DOMKeyframesDefinition, DynamicAnimatio
 import { DeepPartial } from "../../../../util/data";
 import { GameState } from "../../../player/gameState";
 import { TransformDefinitions } from "./type";
-import { Align, Coord2D, IPosition } from "./position";
+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";
 export type Transformers = "position" | "opacity" | "scale" | "rotation" | "display" | "src" | "backgroundColor" | "backgroundOpacity" | "transform";
 export type TransformHandler<T> = (value: T) => DOMKeyframesDefinition;
 export type TransformersMap = {
@@ -52,7 +53,7 @@ export declare class Transform<T extends TransformDefinitions.Types = TransformD
         backgroundImage?: string;
         backgroundColor?: string;
     };
-    static mergePosition(a: IPosition | undefined, b: IPosition | undefined): Coord2D;
+    static mergePosition(a: RawPosition | undefined, b: RawPosition | undefined): Coord2D;
     static mergeState<T>(state: any, props: any): DeepPartial<T>;
     /**
      * @example
@@ -62,9 +63,11 @@ export declare class Transform<T extends TransformDefinitions.Types = TransformD
      * return <div ref={scope} />
      * ```
      */
-    animate<U extends Element = any>({ scope, animate }: {
-        scope: TransformDefinitions.FramerAnimationScope<U>;
-        animate: TransformDefinitions.FramerAnimate;
+    animate({ scope, overwrites }: {
+        scope: React.MutableRefObject<HTMLImageElement | null>;
+        overwrites?: Partial<{
+            [K in Transformers]?: TransformHandler<any>;
+        }>;
     }, gameState: GameState, state: SequenceProps<T>, after?: (state: DeepPartial<T>) => void): Promise<void>;
     /**
      * @example
@@ -88,7 +91,9 @@ 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>): DOMKeyframesDefinition;
+    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;

package/dist/game/nlcore/elements/transition/base.d.ts

@@ -1,7 +1,8 @@
 import { EventDispatcher } from "../../../../util/data";
 import { ElementProp, EventTypes, ITransition } from "./type";
-import { AnimationPlaybackControls, ValueAnimationTransition } from "framer-motion";
+import type { AnimationPlaybackControls, ValueAnimationTransition } from "framer-motion";
 export declare class Base<T extends ElementProp> implements ITransition<T> {
+    controller: AnimationPlaybackControls | null | undefined;
     events: EventDispatcher<EventTypes<[T[]]>>;
     start(_onComplete?: () => void): void;
     toElementProps(): T[];

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

@@ -1,6 +1,6 @@
 import type { EventDispatcher } from "../../../../util/data";
 import React from "react";
-import { DOMKeyframesDefinition } from "framer-motion";
+import type { DOMKeyframesDefinition, AnimationPlaybackControls } from "framer-motion";
 export type ElementProp<T extends Element = Element, U extends React.HTMLAttributes<T> = React.HTMLAttributes<T>> = React.JSX.IntrinsicAttributes & React.ClassAttributes<T> & React.HTMLAttributes<T> & U;
 export type ImgElementProp = ElementProp<HTMLImageElement, React.ImgHTMLAttributes<HTMLImageElement>>;
 export type CSSElementProp<T extends React.CSSProperties | DOMKeyframesDefinition> = ElementProp & {
@@ -9,6 +9,7 @@ export type CSSElementProp<T extends React.CSSProperties | DOMKeyframesDefinitio
 export type CSSProps = React.CSSProperties;
 export interface ITransition<T extends ElementProp = {}> {
     events: EventDispatcher<EventTypes<[T[]]>>;
+    controller: AnimationPlaybackControls | null | undefined;
     start(onComplete?: () => void): void;
     toElementProps(): T[];
     setSrc(src: string): void;

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

@@ -4,6 +4,7 @@ import { Storable } from "./store/storable";
 import { Story } from "./elements/story";
 import { LogicAction } from "./action/logicAction";
 import { GameState } from "../player/gameState";
+import { ComponentsTypes } from "../player/elements/type";
 declare const IdManager_base: {
     new (): {};
     _instance: {} | null;
@@ -26,6 +27,9 @@ declare enum GameSettingsNamespace {
 }
 export declare class Game {
     static defaultSettings: GameSettings;
+    static ComponentTypes: {
+        [K in keyof ComponentsTypes]: K;
+    };
     static DefaultConfig: GameConfig;
     static GameSettingsNamespace: typeof GameSettingsNamespace;
     readonly config: Readonly<GameConfig>;
@@ -36,6 +40,7 @@ export declare class Game {
      */
     constructor(config: DeepPartial<GameConfig>);
     static getIdManager(): IdManager;
+    useComponent<T extends keyof ComponentsTypes>(key: T, components: ComponentsTypes[T]): this;
     getLiveGame(): LiveGame;
     private createLiveGame;
 }
@@ -64,15 +69,28 @@ export declare class LiveGame {
      * Start a new game
      */
     newGame(): this;
+    /**
+     * Load a saved game
+     *
+     * Note: Different versions of the game won't be able to load each other's saved games
+     */
     deserialize(savedGame: SavedGame, { gameState }: {
         gameState: GameState;
     }): void;
+    /**
+     * Serialize the current game state
+     *
+     * You can use this to save the game state to a file or a database
+     *
+     * Note: Different versions of the game won't be able to load each other's saved games
+     */
     serialize({ gameState }: {
         gameState: GameState;
     }): SavedGame;
     getCurrentAction(): LogicAction.Actions | null;
     setCurrentAction(action: LogicAction.Actions | null): this;
     next(state: GameState): CalledActionResult | Awaitable<CalledActionResult, CalledActionResult> | null;
+    abortAwaiting(): void;
     executeAction(state: GameState, action: LogicAction.Actions): LogicAction.Actions | Awaitable<CalledActionResult, CalledActionResult> | null;
 }
 declare const _default: {

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

@@ -0,0 +1,124 @@
+import { ContentNode, RawData } from "./action/tree/actionTree";
+import { LogicAction } from "./action/logicAction";
+import { ElementStateRaw } from "./elements/story";
+import { PlayerStateData } from "../player/gameState";
+import { StorableData } from "./store/type";
+import { MenuComponent, SayComponent } from "../player/elements/type";
+export interface SavedGame {
+    name: string;
+    version: string;
+    meta: {
+        created: number;
+        updated: number;
+    };
+    game: {
+        store: {
+            [key: string]: StorableData;
+        };
+        elementState: RawData<ElementStateRaw>[];
+        nodeChildIdMap: Record<string, string>;
+        stage: PlayerStateData;
+        currentScene: number;
+        currentAction: string | null;
+    };
+}
+export type GameConfig = {
+    version: string;
+    player: {
+        contentContainerId: string;
+        /**
+         * The aspect ratio of the game
+         * Ex: 16/9, 4/3, 1/1
+         */
+        aspectRatio: number;
+        /**
+         * The minimum width and height of the player in pixels
+         */
+        minWidth: number;
+        /**
+         * The minimum width and height of the player in pixels
+         */
+        minHeight: number;
+        width: number | string;
+        height: number | string;
+        /**
+         * When player presses one of these keys, the game will skip the current action
+         *
+         * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
+         */
+        skipKey: string[];
+        /**
+         * The interval in milliseconds between each skip action.
+         * ex: 100ms means the player can skip 10 actions per second.
+         * higher value means faster skipping.
+         */
+        skipInterval: number;
+    };
+    elements: {
+        say: {
+            /**
+             * When the player presses one of these keys, the game will show the next sentence
+             *
+             * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
+             */
+            nextKey: string[];
+            /**
+             * The speed of the text effect in milliseconds.
+             * higher value means slower text effect.
+             * default: 50
+             */
+            textInterval: number;
+            use: SayComponent;
+        };
+        img: {
+            /**
+             * If true, the game will show a warning when loading takes longer than `elements.img.slowLoadThreshold`
+             */
+            slowLoadWarning: boolean;
+            slowLoadThreshold: number;
+        };
+        menu: {
+            use: MenuComponent;
+        };
+    };
+    elementStyles: {
+        say: {
+            /**
+             * Custom class for the say container
+             * Ex: "rounded-md shadow-md" for rounded and shadowed container
+             */
+            container: string;
+            nameText: string;
+            textContainer: string;
+            textSpan: string;
+        };
+        menu: {
+            container: string;
+            choiceButton: string;
+            choiceButtonText: string;
+        };
+    };
+    app: {
+        debug: boolean;
+        /**
+         * Log level for the logger
+         */
+        logger: {
+            log: boolean;
+            info: boolean;
+            warn: boolean;
+            error: boolean;
+            debug: boolean;
+            trace: boolean;
+        };
+    };
+};
+export type GameSettings = {
+    volume: number;
+};
+export type CalledActionResult<T extends keyof LogicAction.ActionContents = any> = {
+    [K in keyof LogicAction.ActionContents]: {
+        type: T extends undefined ? K : T;
+        node: ContentNode<LogicAction.ActionContents[T extends undefined ? K : T]> | null;
+    };
+}[keyof LogicAction.ActionContents];

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

@@ -6,7 +6,7 @@ export declare class Namespace<T extends NameSpaceContent<keyof T>> {
     constructor(name: string, initContent: T, key?: string);
     static isSerializable(value: any): boolean;
     set<Key extends keyof T>(key: Key, value: T[Key]): this;
-    get<Key extends keyof T>(key: Key): T[Key];
+    get<Key extends keyof T = any>(key: Key): T[Key];
     toData(): {
         [key: string]: WrappedStorableData;
     };
@@ -27,8 +27,8 @@ export declare class Storable {
     };
     constructor();
     addNamespace<T extends NameSpaceContent<keyof T>>(namespace: Namespace<T>): this;
-    getNamespace<T extends NameSpaceContent<keyof T>>(key: string): Namespace<T>;
-    setNamespace<T extends NameSpaceContent<keyof T>>(key: string, namespace: Namespace<T>): this;
+    getNamespace<T extends NameSpaceContent<keyof T> = any>(key: string): Namespace<T>;
+    setNamespace<T extends NameSpaceContent<keyof T> = any>(key: string, namespace: Namespace<T>): this;
     getNamespaces(): {
         [key: string]: Namespace<any>;
     };

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

@@ -1,4 +1,4 @@
-import { IPosition } from "./elements/transform/position";
+import { IPosition, RawPosition } from "./elements/transform/position";
 export type color = string | {
     r: number;
     g: number;
@@ -35,12 +35,11 @@ export type Background = {
 };
 export type CommonImagePosition = "left" | "center" | "right";
 export type CommonImage = {
-    height?: number;
-    width?: number;
     scale?: number;
     rotation?: number;
-    position?: IPosition;
-    opacity: number;
+    position?: RawPosition | IPosition;
+    opacity?: number;
+    alt?: string;
 };
 export declare const ImagePosition: {
     [K in CommonImagePosition]: K;