narraleaf-react 0.0.1-beta.1

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

@@ -0,0 +1,102 @@
+import { CalledActionResult } from "@core/gameTypes";
+import { EventDispatcher } from "../../util/data";
+import { Character, Sentence } from "../nlcore/elements/text";
+import { Choice, MenuData } from "../nlcore/elements/menu";
+import { Image, ImageEventTypes } from "../nlcore/elements/image";
+import { Scene } from "../nlcore/elements/scene";
+import { Sound } from "../nlcore/elements/sound";
+import * as Howler from "howler";
+import { SrcManager } from "../nlcore/elements/srcManager";
+import { LogicAction } from "../nlcore/action/logicAction";
+import { Storable } from "../nlcore/store/storable";
+import { Game } from "../nlcore/game";
+type Clickable<T, U = undefined> = {
+    action: T;
+    onClick: U extends undefined ? () => void : (arg0: U) => void;
+};
+type TextElement = {
+    character: Character | null;
+    sentence: Sentence;
+    id: string;
+};
+type MenuElement = {
+    prompt: Sentence;
+    choices: Choice[];
+};
+type PlayerStateElement = {
+    texts: Clickable<TextElement>[];
+    menus: Clickable<MenuElement, Choice>[];
+    images: Image[];
+};
+export type PlayerState = {
+    sounds: Sound[];
+    srcManagers: SrcManager[];
+    elements: {
+        scene: Scene;
+        ele: PlayerStateElement;
+    }[];
+};
+export type PlayerStateData = {
+    elements: {
+        scene: string;
+        ele: {
+            images: string[];
+        };
+    }[];
+};
+export type PlayerAction = CalledActionResult;
+interface StageUtils {
+    forceUpdate: () => void;
+    next: () => void;
+    dispatch: (action: PlayerAction) => void;
+}
+type GameStateEvents = {
+    "event:state.ready": [];
+};
+export declare class GameState {
+    static EventTypes: {
+        [K in keyof GameStateEvents]: K;
+    };
+    state: PlayerState;
+    currentHandling: CalledActionResult | null;
+    stage: StageUtils;
+    game: Game;
+    readonly events: EventDispatcher<GameStateEvents>;
+    constructor(game: Game, stage: StageUtils);
+    findElementByScene(scene: Scene): {
+        scene: Scene;
+        ele: PlayerStateElement;
+    } | null;
+    findElementByImage(image: Image): {
+        scene: Scene;
+        ele: PlayerStateElement;
+    } | null;
+    addScene(scene: Scene): this;
+    popScene(): this;
+    removeScene(scene: Scene): this;
+    getSceneElements(): {
+        scene: Scene;
+        ele: PlayerStateElement;
+    }[];
+    getLastScene(): Scene | null;
+    sceneExists(scene?: Scene): boolean;
+    handle(action: PlayerAction): this;
+    createText(id: string, sentence: Sentence, afterClick?: () => void, scene?: Scene): void;
+    createMenu(menu: MenuData, afterChoose?: (choice: Choice) => void, scene?: Scene): void;
+    createImage(image: Image, scene?: Scene): this;
+    disposeImage(image: Image, scene?: Scene): this;
+    playSound(howl: Howler.Howl, onEnd?: () => void): any;
+    getHowl(): typeof Howler.Howl;
+    animateImage<T extends keyof ImageEventTypes>(type: T, target: Image, args: ImageEventTypes[T], onEnd: () => void): undefined;
+    registerSrcManager(srcManager: SrcManager): this;
+    offSrcManager(srcManager: SrcManager): this;
+    getStorable(): Storable;
+    toData(): PlayerStateData;
+    loadData(data: PlayerStateData, actions: LogicAction.Actions[]): void;
+    private getElementMap;
+    private removeElements;
+    private _getLastSceneIfNot;
+    private anyEvent;
+    private createWaitableAction;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { Sound } from "../../nlcore/elements/sound";
+import { Src } from "../../nlcore/elements/srcManager";
+import { EventDispatcher } from "../../../util/data";
+import { Image } from "../../nlcore/elements/image";
+export type PreloadedSrcTypes = "image" | "audio" | "video";
+export type PreloadedSrc<T extends PreloadedSrcTypes = any> = ({
+    type: "image";
+    src: Image;
+} | {
+    type: "audio";
+    src: Sound;
+} | {
+    type: "video";
+    src: string;
+}) & (T extends undefined ? {} : ({
+    type: T;
+} & T extends "image" ? {
+    src: Image;
+} : T extends "audio" ? {
+    src: Sound;
+} : T extends "video" ? {
+    src: string;
+} : {}));
+export type PreloadedEventTypes = {
+    "event:preloaded.add": [PreloadedSrc | string];
+    "event:preloaded.remove": [PreloadedSrc | string];
+    "event:preloaded.change": [];
+    "event:preloaded.mount": [];
+    "event:preloaded.ready": [];
+};
+export declare class Preloaded {
+    static EventTypes: {
+        [K in keyof PreloadedEventTypes]: K;
+    };
+    preloaded: PreloadedSrc[];
+    events: EventDispatcher<PreloadedEventTypes>;
+    add<T extends PreloadedSrcTypes = PreloadedSrcTypes>(src: PreloadedSrc<T>): this;
+    get<T extends PreloadedSrcTypes = any>(src: string): PreloadedSrc<T> | undefined;
+    has(src: string): boolean;
+    has(src: string[]): boolean;
+    remove(src: string): this;
+    remove(src: PreloadedSrc): this;
+    remove(src: string[]): this;
+    remove(src: PreloadedSrc[]): this;
+    clear(): this;
+    getSrc(src: Src | string): string;
+}

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

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+import React from "react";
+export default function Isolated({ children, className }: Readonly<{
+    children: ReactNode;
+    className?: string;
+}>): React.JSX.Element;

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

@@ -0,0 +1,5 @@
+import React from "react";
+export default function Main({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): React.JSX.Element;

package/dist/game/player/provider/game-state.d.ts

@@ -0,0 +1,12 @@
+import React, { ReactNode } from "react";
+import { Game } from "../../nlcore/game";
+type GameContextType = {
+    game: Game;
+    setGame: (update: (prevGame: Game) => Game) => void;
+};
+export declare function GameProvider({ children, game }: {
+    children?: ReactNode;
+    game?: Game;
+}): React.JSX.Element;
+export declare function useGame(): GameContextType;
+export {};

package/dist/game/player/provider/preloaded.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { Preloaded } from "../lib/Preloaded";
+type PreloadedContextType = {
+    preloaded: Preloaded;
+};
+export declare function PreloadedProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function usePreloaded(): PreloadedContextType;
+export {};

package/dist/game/player/provider/providers.d.ts

@@ -0,0 +1,5 @@
+import "client-only";
+import React from "react";
+export default function GameProviders({ children }: Readonly<{
+    children?: React.ReactNode;
+}>): React.JSX.Element;

package/dist/game/player/provider/ratio.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+type Ratio = {
+    w: number;
+    h: number;
+    updateStyle: () => void;
+    style: React.CSSProperties;
+    s: {
+        style: React.CSSProperties;
+    };
+    min: {
+        w: number;
+        h: number;
+    };
+};
+type ThemeContextType = {
+    ratio: Ratio;
+    setRatio: (ratio: Ratio) => void;
+};
+export declare function AspectRatioProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useAspectRatio(): ThemeContextType;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./game/nlcore/common/core";
+export * from "./game/nlcore/common/player";