narraleaf-react 0.2.0 → 0.2.2

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

@@ -141,5 +141,5 @@ export declare const PersistentActionTypes: {
     readonly set: "persistent:set";
 };
 export type PersistentActionContentType = {
-    [K in typeof PersistentActionTypes[keyof typeof PersistentActionTypes]]: K extends "persistent:action" ? any : K extends "persistent:set" ? [string, any] : any;
+    [K in typeof PersistentActionTypes[keyof typeof PersistentActionTypes]]: K extends "persistent:action" ? any : K extends "persistent:set" ? [string, unknown | ((value: unknown) => unknown)] : any;
 };

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

@@ -3,6 +3,7 @@ import { Image } from "../../elements/displayable/image";
 import { GameState } from "../../../player/gameState";
 import type { CalledActionResult } from "../../gameTypes";
 import { Awaitable } from "../../../../util/data";
+import { ContentNode } from "../../action/tree/actionTree";
 import { TypedAction } from "../../action/actions";
 export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof ImageActionTypes] = typeof ImageActionTypes[keyof typeof ImageActionTypes]> extends TypedAction<ImageActionContentType, T, Image> {
     static ActionTypes: {
@@ -20,5 +21,7 @@ export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof
         readonly initWearable: "image:initWearable";
         readonly setAppearance: "image:setAppearance";
     };
+    type: T;
+    contentNode: ContentNode<ImageActionContentType[T]>;
     executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
 }

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

@@ -1,5 +1,5 @@
 import { Game } from "../game";
 import { GameState } from "../../player/gameState";
 import { Storable, Namespace } from "../elements/persistent/storable";
-import { LiveGame } from "../liveGame";
+import { LiveGame } from "../game/liveGame";
 export { LiveGame, GameState, Game, Storable, Namespace, };

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

@@ -11,4 +11,5 @@ export declare class Word<T extends string | DynamicWord | Pausing = string | Dy
     static bold(text: string | Word): Word;
     static italic(text: string | Word): Word;
     constructor(text: T, config?: Partial<WordConfig>);
+    toString(): string;
 }

package/dist/game/nlcore/elements/persistent/storable.d.ts

@@ -13,6 +13,7 @@ export declare class Storable {
     getNamespace<T extends NameSpaceContent<keyof T> = any>(key: string): Namespace<T>;
     setNamespace<T extends NameSpaceContent<keyof T> = any>(key: string, namespace: Namespace<T>): this;
     hasNamespace(key: string): boolean;
+    removeNamespace(key: string): this;
     getNamespaces(): {
         [key: string]: Namespace<any>;
     };

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

@@ -8,17 +8,19 @@ import { Word } from "../elements/character/word";
 import { DynamicWord, DynamicWordResult } from "../elements/character/sentence";
 import { LambdaHandler } from "../elements/type";
 type PersistentContent = {
-    [key: string]: StorableType;
+    [K in string]: StorableType;
 };
 type ChainedPersistent<T extends PersistentContent> = Proxied<Persistent<T>, Chained<LogicAction.Actions>>;
+type DynamicPersistentData = {
+    [K in string]: StorableType;
+};
 export declare class Persistent<T extends PersistentContent> extends Actionable<null> {
-    private namespace;
-    private defaultContent;
     constructor(namespace: string, defaultContent: T);
     /**
      * @chainable
      */
     set<K extends StringKeyOf<T>>(key: K, value: T[K]): ChainedPersistent<T>;
+    set<K extends StringKeyOf<T>>(key: K, handler: (value: T[K]) => T[K]): ChainedPersistent<T>;
     /**
      * Determine whether the values are equal, can be used in {@link Condition}
      */
@@ -47,6 +49,10 @@ export declare class Persistent<T extends PersistentContent> extends Actionable<
      * ```
      */
     toWord<K extends StringKeyOf<T>>(key: K): Word<DynamicWord>;
+    /**
+     * Alias of {@link toWord}
+     */
+    get<K extends StringKeyOf<T>>(key: K): Word<DynamicWord>;
     /**
      * Create a conditional word
      *
@@ -63,5 +69,14 @@ export declare class Persistent<T extends PersistentContent> extends Actionable<
      * ```
      */
     conditional(condition: Lambda<boolean> | LambdaHandler<boolean>, ifTrue: DynamicWordResult, ifFalse: DynamicWordResult): Word;
+    /**
+     * Evaluate the JavaScript function and determine whether the result is true
+     */
+    evaluate<K extends StringKeyOf<T>>(key: K, fn: (value: T[K]) => boolean): Lambda<boolean>;
+}
+/**
+ * Only for internal use, don't use this class directly
+ */
+export declare class DynamicPersistent extends Persistent<DynamicPersistentData> {
 }
 export {};

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

@@ -7,6 +7,7 @@ import { IImageTransition, ITransition } from "../elements/transition/type";
 import { Sound, SoundDataRaw, VoiceIdMap, VoiceSrcGenerator } from "../elements/sound";
 import { TransformDefinitions } from "../elements/transform/type";
 import { ImageDataRaw, VirtualImageProxy } from "../elements/displayable/image";
+import { Persistent } from "../common/core";
 import { Chained, Proxied } from "../action/chain";
 import { RGBColor } from "../common/Utils";
 import Actions = LogicAction.Actions;
@@ -60,6 +61,7 @@ export type SceneEventTypes = {
     "event:displayable.init": [];
 };
 export declare class Scene extends Constructable<Actions, Scene> implements EventfulDisplayable {
+    readonly local: Persistent<any>;
     constructor(name: string, config?: Partial<ISceneConfig>);
     /**
      * Activate the scene

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

@@ -2,7 +2,7 @@ import { Game } from "../game";
 import { Actionable } from "../action/actionable";
 import { GameState } from "../../player/gameState";
 import type { Storable } from "../elements/persistent/storable";
-import { LiveGame } from "../liveGame";
+import { LiveGame } from "../game/liveGame";
 export interface ScriptCtx {
     gameState: GameState;
     game: Game;

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

@@ -18,6 +18,18 @@ export type TransformersMap = {
     "fontColor": color;
 };
 export declare class Transform<T extends TransformDefinitions.Types = object> {
+    /**
+     * Go to the left side of the stage
+     */
+    static left(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
+    /**
+     * Go to the right side of the stage
+     */
+    static right(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
+    /**
+     * Go to the center of the stage
+     */
+    static center(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
     /**
      * @example
      * ```ts

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

@@ -0,0 +1,84 @@
+import { EventDispatcher, MultiLock } from "../../../util/data";
+import type { SavedGame } from "../gameTypes";
+import { GameState } from "../../player/gameState";
+import { Storable } from "../elements/persistent/storable";
+import { Game } from "../game";
+import { LiveGameEventHandler, LiveGameEventToken } from "../types";
+import { Character } from "../elements/character";
+import { Sentence } from "../elements/character/sentence";
+type LiveGameEvent = {
+    "event:character.prompt": [
+        {
+            /**
+             * The character who says the sentence
+             */
+            character: Character | null;
+            /**
+             * The sentence said by the character
+             */
+            sentence: Sentence;
+            /**
+             * The text of the sentence
+             */
+            text: string;
+        }
+    ];
+    "event:menu.choose": [
+        {
+            /**
+             * The sentence selected by the player
+             */
+            sentence: Sentence;
+            /**
+             * The text of the sentence
+             */
+            text: string;
+        }
+    ];
+};
+export declare class LiveGame {
+    static DefaultNamespaces: {
+        game: {};
+    };
+    static GameSpacesKey: {
+        readonly game: "game";
+    };
+    static EventTypes: {
+        readonly "event:character.prompt": "event:character.prompt";
+        readonly "event:menu.choose": "event:menu.choose";
+    };
+    game: Game;
+    gameLock: MultiLock;
+    events: EventDispatcher<LiveGameEvent>;
+    getStorable(): Storable;
+    /**
+     * 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
+     */
+    serialize(): SavedGame;
+    /**
+     * Load a saved game
+     *
+     * 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): void;
+    /**
+     * When a character says something
+     */
+    onCharacterPrompt(fc: LiveGameEventHandler<LiveGameEvent["event:character.prompt"]>): LiveGameEventToken;
+    /**
+     * When a player chooses a menu
+     */
+    onMenuChoose(fc: LiveGameEventHandler<LiveGameEvent["event:menu.choose"]>): LiveGameEventToken;
+    /**
+     * Start a new game
+     */
+    newGame(): this;
+    getGameState(): GameState | undefined;
+}
+export {};

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

@@ -2,7 +2,7 @@ import type { GameConfig } from "./gameTypes";
 import { DeepPartial } from "../../util/data";
 import { LogicAction } from "./action/logicAction";
 import { ComponentsTypes } from "../player/elements/type";
-import { LiveGame } from "./liveGame";
+import { LiveGame } from "./game/liveGame";
 import { Preference } from "./game/preference";
 declare enum GameSettingsNamespace {
     game = "game"

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

@@ -93,6 +93,18 @@ export type GameConfig = {
          * The number of actions will be predicted and preloaded
          */
         maxPreloadActions: number;
+        /**
+         * Src of the cursor image, if null, the game will show the default cursor
+         */
+        cursor: string | null;
+        /**
+         * Cursor width in pixels
+         */
+        cursorWidth: number;
+        /**
+         * Cursor height in pixels
+         */
+        cursorHeight: number;
     };
     elements: {
         say: {

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

@@ -62,3 +62,7 @@ export type EventfulDisplayableEvents = {
 };
 export interface EventfulDisplayable {
 }
+export type LiveGameEventHandler<T extends Array<any>> = (...args: T) => void;
+export type LiveGameEventToken = {
+    cancel(): void;
+};

package/dist/game/player/elements/menu/Menu.d.ts

@@ -1,3 +1,3 @@
 import React from "react";
 import { MenuElementProps } from "../../elements/menu/type";
-export default function Menu({ prompt, choices, afterChoose, state, }: Readonly<MenuElementProps>): React.JSX.Element;
+export default function Menu({ prompt, choices, afterChoose, state, words, }: Readonly<MenuElementProps>): React.JSX.Element;

package/dist/game/player/elements/menu/type.d.ts

@@ -1,9 +1,13 @@
 import type { Choice } from "../../../nlcore/elements/menu";
 import type { GameState } from "../../gameState";
 import { Sentence } from "../../../nlcore/elements/character/sentence";
+import { Word } from "../../../nlcore/elements/character/word";
+import { Pausing } from "../../../nlcore/elements/character/pause";
+import { Chosen } from "../../type";
 export interface MenuElementProps {
     prompt: Sentence;
     choices: Choice[];
-    afterChoose: (choice: Choice) => void;
+    afterChoose: (choice: Chosen) => void;
     state: GameState;
+    words: Word<Pausing | string>[];
 }

package/dist/game/player/elements/say/Sentence.d.ts

@@ -1,7 +1,9 @@
 import React from "react";
 import { GameState } from "../../gameState";
 import { Sentence as GameSentence } from "../../../nlcore/elements/character/sentence";
-export default function Sentence({ sentence, gameState, useTypeEffect, onCompleted, finished, count, className, }: Readonly<{
+import { Word } from "../../../nlcore/elements/character/word";
+import { Pausing } from "../../../nlcore/elements/character/pause";
+export default function Sentence({ sentence, gameState, useTypeEffect, onCompleted, finished, count, className, words: w, }: Readonly<{
     sentence: GameSentence;
     gameState: GameState;
     useTypeEffect?: boolean;
@@ -9,4 +11,5 @@ export default function Sentence({ sentence, gameState, useTypeEffect, onComplet
     finished?: boolean;
     count?: number;
     className?: string;
+    words?: Word<string | Pausing>[];
 }>): React.JSX.Element;

package/dist/game/player/elements/say/type.d.ts

@@ -1,13 +1,16 @@
 import type { Character } from "../../../nlcore/elements/character";
 import type { GameState } from "../../gameState";
 import { Sentence } from "../../../nlcore/elements/character/sentence";
+import { Word } from "../../../nlcore/elements/character/word";
+import { Pausing } from "../../../nlcore/elements/character/pause";
 export interface SayElementProps {
     action: {
         sentence: Sentence;
         character: Character | null;
+        words: Word<Pausing | string>[];
     };
     /**
-     * Callback function to be called when player triggers the next action
+     * Callback function to be called when the player triggers the next action
      */
     onClick?: () => void;
     useTypeEffect?: boolean;

package/dist/game/player/elements/type.d.ts

@@ -6,7 +6,7 @@ import clsx from "clsx";
 import { Game } from "../../nlcore/game";
 import { GameState } from "../gameState";
 import { Storable } from "../../nlcore/elements/persistent/storable";
-import { LiveGame } from "../../nlcore/liveGame";
+import { LiveGame } from "../../nlcore/game/liveGame";
 export type Components<T extends Record<string, any>> = (props: Readonly<T>) => React.JSX.Element;
 export type SayComponent = Components<SayElementProps>;
 export type MenuComponent = Components<MenuElementProps>;

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

@@ -15,9 +15,10 @@ import { Sentence } from "../nlcore/elements/character/sentence";
 import { Text, TextEventTypes } from "../nlcore/elements/displayable/text";
 import { Logger } from "../../util/logger";
 import { Story } from "../nlcore/elements/story";
+import { Chosen } from "./type";
 type PlayerStateElement = {
     texts: Clickable<TextElement>[];
-    menus: Clickable<MenuElement, Choice>[];
+    menus: Clickable<MenuElement, Chosen>[];
     displayable: LogicAction.DisplayableElements[];
 };
 export type PlayerState = {
@@ -107,16 +108,15 @@ export declare class GameState {
     getSceneByName(name: string): Scene | null;
     getStory(): Story;
     /**
-     * Dispose the game state
+     * Dispose of the game state
      *
-     * This is an irreversible action, once disposed, the game state cannot be used again.
+     * This is an irreversible action; once disposed of, the game state can't be used again.
      *
-     * Do not call this method directly
+     * Don't call this method directly
      */
     dispose(): void;
     toData(): PlayerStateData;
     loadData(data: PlayerStateData, elementMap: Map<string, LogicAction.GameElement>): void;
-    initScenes(): void;
     getLastSceneIfNot(scene: Scene | null | void): Scene;
     private getElementMap;
     private removeElements;

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

@@ -1,6 +1,8 @@
 import { Character } from "../nlcore/elements/character";
 import { Choice } from "../nlcore/elements/menu";
 import { Sentence } from "../nlcore/elements/character/sentence";
+import { Word } from "../nlcore/elements/character/word";
+import { Pausing } from "../nlcore/elements/character/pause";
 export type Clickable<T, U = undefined> = {
     action: T;
     onClick: U extends undefined ? () => void : (arg0: U) => void;
@@ -9,8 +11,10 @@ export type TextElement = {
     character: Character | null;
     sentence: Sentence;
     id: string;
+    words: Word<Pausing | string>[];
 };
 export type MenuElement = {
     prompt: Sentence;
     choices: Choice[];
+    words: Word<Pausing | string>[];
 };

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

@@ -0,0 +1,6 @@
+import React from "react";
+export default function Cursor({ src, width, height, }: Readonly<{
+    src: string;
+    width: number;
+    height: number;
+}>): React.JSX.Element;

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

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

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

@@ -1 +1,5 @@
+import { Choice } from "../nlcore/elements/menu";
 export * from "./elements/type";
+export type Chosen = Choice & {
+    evaluated: string;
+};