narraleaf-react 0.8.1 → 0.8.3

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

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

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

@@ -5,22 +5,12 @@ import { LogicAction } from "../../action/logicAction";
 import { TypedAction } from "../../action/actions";
 import { Story } from "../../elements/story";
 import { ActionSearchOptions } from "../../types";
+import { ActionExecutionInjection } from "../action";
 export declare class ConditionAction<T extends typeof ConditionActionTypes[keyof typeof ConditionActionTypes] = typeof ConditionActionTypes[keyof typeof ConditionActionTypes]> extends TypedAction<ConditionActionContentType, T, Condition> {
     static ActionTypes: {
         readonly action: "condition:action";
     };
-    executeAction(gameState: GameState): ({
-        type: T;
-        node: import("../../action/tree/actionTree").RenderableNode | null;
-        wait?: undefined;
-    } | {
-        type: T;
-        node: null;
-        wait: {
-            type: "all";
-            stackModels: import("../stackModel").StackModel[];
-        };
-    })[];
+    executeAction(gameState: GameState, injection: ActionExecutionInjection): import("../action").ExecutedActionResult;
     getFutureActions(story: Story, options: ActionSearchOptions): LogicAction.Actions[];
     stringify(story: Story, seen: Set<LogicAction.Actions>, strict: boolean): string;
 }

package/dist/game/nlcore/elements/built-in/Gallery.d.ts

@@ -129,7 +129,7 @@ export declare class Gallery<Metadata extends Record<string, any>> extends Servi
      * @param name - The name of the item to get the metadata of
      * @returns The metadata of the item
      */
-    $get(name: string): Metadata;
+    $get(name: string): Metadata | undefined;
     /**
      * Set the metadata of an item
      * @param name - The name of the item to set the metadata of

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

@@ -4,7 +4,7 @@ import { Chained, Proxied } from "../action/chain";
 import { LambdaHandler, ActionStatements } from "../elements/type";
 export declare class Lambda<T = any> {
 }
-export declare class Condition<Closed extends true | false = false> extends Actionable {
+export declare class Condition<Closed extends true | false = false> extends Actionable<null, Condition<true | false>> {
     /**
      * @chainable
      */

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

@@ -3,20 +3,30 @@ import { Actionable } from "../action/actionable";
 import { Chained, Proxied } from "../action/chain";
 import { Sentence, SentencePrompt } from "../elements/character/sentence";
 import Actions = LogicAction.Actions;
-import { ActionStatements } from "./type";
+import { ActionStatements, LambdaHandler } from "./type";
+import { Lambda } from "./condition";
 export type MenuConfig = {};
 export type MenuChoice = {
     action: ActionStatements;
     prompt: SentencePrompt | Sentence;
+    config?: {
+        disabled?: Lambda<boolean> | LambdaHandler<boolean>;
+        hidden?: Lambda<boolean> | LambdaHandler<boolean>;
+    };
 };
 export type Choice = {
     action: Actions[];
     prompt: Sentence;
+    config: ChoiceConfig;
 };
 export type MenuData = {
     prompt: Sentence | null;
     choices: Choice[];
 };
+export type ChoiceConfig = {
+    disabled?: Lambda<boolean>;
+    hidden?: Lambda<boolean>;
+};
 export declare class Menu extends Actionable<any, Menu> {
     /**
      * Create a menu with a prompt
@@ -42,4 +52,46 @@ export declare class Menu extends Actionable<any, Menu> {
     choose(prompt: Sentence, action: ActionStatements): Proxied<Menu, Chained<LogicAction.Actions>>;
     choose(prompt: SentencePrompt, action: ActionStatements): Proxied<Menu, Chained<LogicAction.Actions>>;
     choose(arg0: Sentence | MenuChoice | SentencePrompt, arg1?: ActionStatements): Proxied<Menu, Chained<LogicAction.Actions>>;
+    /**
+     * Magic method to hide the last choice if the condition is true
+     * @example
+     * ```ts
+     * menu.choose(
+     *   // ...
+     * ).hideIf(persis.isTrue("flag"));
+     * ```
+     *
+     * **Note**: This method will override the last choice's config.hidden
+     */
+    hideIf(condition: Lambda<boolean> | LambdaHandler<boolean>): Proxied<Menu, Chained<LogicAction.Actions>>;
+    /**
+     * Magic method to disable the last choice if the condition is true
+     * @example
+     * ```ts
+     * menu.choose(
+     *   // ...
+     * ).disableIf(persis.isTrue("flag"));
+     * ```
+     */
+    disableIf(condition: Lambda<boolean> | LambdaHandler<boolean>): Proxied<Menu, Chained<LogicAction.Actions>>;
+    /**
+     * Add a choice, only enable when the condition is true
+     * @example
+     * ```ts
+     * menu.enableWhen(persis.isTrue("flag"), "Go left", [
+     *     character.say("I went left")
+     * ]);
+     * ```
+     */
+    enableWhen(condition: Lambda<boolean> | LambdaHandler<boolean>, prompt: Sentence, action: ActionStatements): Proxied<Menu, Chained<LogicAction.Actions>>;
+    /**
+     * Add a choice, only show when the condition is true
+     * @example
+     * ```ts
+     * menu.showWhen(persis.isTrue("flag"), "Go left", [
+     *     character.say("I went left")
+     * ]);
+     * ```
+     */
+    showWhen(condition: Lambda<boolean> | LambdaHandler<boolean>, prompt: Sentence, action: ActionStatements): Proxied<Menu, Chained<LogicAction.Actions>>;
 }

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

@@ -21,15 +21,15 @@ export declare class Persistent<T extends PersistentContent> extends Actionable<
      * @param value - The value to assign
      * @returns A chainable persistent action
      */
-    assign(value: Partial<T>): ChainedPersistent<T>;
+    assign(value: Partial<T> | ((value: T) => Partial<T>)): ChainedPersistent<T>;
     /**
      * Determine whether the values are equal, can be used in {@link Condition}
      */
-    equals<K extends StringKeyOf<T>>(key: K, value: T[K]): Lambda<boolean>;
+    equals<K extends StringKeyOf<T>>(key: K, value: T[K] | ((value: T[K]) => T[K])): Lambda<boolean>;
     /**
      * Determine whether the values aren't equal, can be used in {@link Condition}
      */
-    notEquals<K extends StringKeyOf<T>>(key: K, value: T[K]): Lambda<boolean>;
+    notEquals<K extends StringKeyOf<T>>(key: K, value: T[K] | ((value: T[K]) => T[K])): Lambda<boolean>;
     /**
      * Determine whether the value is true, can be used in {@link Condition}
      */

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

@@ -24,24 +24,6 @@ export declare class Story extends Constructable<SceneAction<"scene:action">, St
      * ```
      */
     entry(scene: Scene): this;
-    /**
-     * Register a scene to the story
-     * @example
-     * ```typescript
-     * // register a scene
-     * const story = new Story("story");
-     * const scene1 = new Scene("scene1");
-     * const scene2 = new Scene("scene2");
-     *
-     * story.register(scene1); // Register scene1
-     *
-     * scene2.action([
-     *   scene2.jump("scene1") // Jump to scene1
-     * ]);
-     * ```
-     */
-    registerScene(name: string, scene: Scene): this;
-    registerScene(scene: Scene): this;
     /**
      * Register a Persistent to the story
      *

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

@@ -1,3 +1,3 @@
-import React from "react";
 import { IUserMenuProps } from "../../elements/menu/type";
+import React from "react";
 export declare function DefaultMenu({ items }: IUserMenuProps): React.JSX.Element;

package/dist/game/player/elements/menu/UIMenu/context.d.ts

@@ -1,13 +1,9 @@
-import { Pausing } from "../../../../nlcore/elements/character/pause";
-import { Word } from "../../../../nlcore/elements/character/word";
-import { Choice } from "../../../../nlcore/elements/menu";
 import { GameState } from "../../../../../game/player/gameState";
 import { Chosen } from "../../../type";
 import React from "react";
+import { ChoiceEvaluated } from "../type";
 interface UIMenuContext {
-    evaluated: (Choice & {
-        words: Word<Pausing | string>[];
-    })[];
+    evaluated: ChoiceEvaluated[];
     choose: (choice: Chosen) => void;
     gameState: GameState;
 }

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

@@ -14,3 +14,6 @@ export interface MenuElementProps {
 export interface IUserMenuProps {
     items: number[];
 }
+export type ChoiceEvaluated = Choice & {
+    words: Word<Pausing | string>[];
+};