narraleaf-react 0.8.2 → 0.8.4

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/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,31 @@ 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}
+     * @example
+     * ```typescript
+     * persis.equals("id", persis.get("player_id"));
+     *
+     * // or
+     *
+     * persis.equals("id", (ctx) => ctx.storable.getNamespace("player").get("player_id"));
+     * ```
      */
-    equals<K extends StringKeyOf<T>>(key: K, value: T[K]): Lambda<boolean>;
+    equals<K extends StringKeyOf<T>>(key: K, value: T[K] | Lambda<T[K]> | LambdaHandler<T[K]>): Lambda<boolean>;
     /**
      * Determine whether the values aren't equal, can be used in {@link Condition}
+     * @example
+     * ```typescript
+     * persis.notEquals("id", persis.get("player_id"));
+     *
+     * // or
+     *
+     * persis.notEquals("id", (ctx) => ctx.storable.getNamespace("player").get("player_id"));
+     * ```
      */
-    notEquals<K extends StringKeyOf<T>>(key: K, value: T[K]): Lambda<boolean>;
+    notEquals<K extends StringKeyOf<T>>(key: K, value: T[K] | Lambda<T[K]> | LambdaHandler<T[K]>): Lambda<boolean>;
     /**
      * Determine whether the value is true, can be used in {@link Condition}
      */

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

@@ -1,16 +1,22 @@
 import { Game } from "../game";
+import { LogicAction } from "../action/logicAction";
 import { Actionable } from "../action/actionable";
 import { GameState } from "../../player/gameState";
-import type { Storable } from "../elements/persistent/storable";
+import { Chained, Proxied } from "../action/chain";
+import type { Namespace, Storable } from "../elements/persistent/storable";
 import { LiveGame } from "../game/liveGame";
+import { NameSpaceContent } from "./persistent/type";
+export type NamespaceGetter = <T extends NameSpaceContent<keyof T>>(namespace: string) => Namespace<T>;
 export interface ScriptCtx {
     gameState: GameState;
     game: Game;
     liveGame: LiveGame;
     storable: Storable;
+    $: NamespaceGetter;
 }
 type ScriptRun = (ctx: ScriptCtx) => ScriptCleaner | void;
 export declare class Script extends Actionable<object> {
+    static execute(handler: ScriptRun): Proxied<Script, Chained<LogicAction.Actions>>;
     constructor(handler: ScriptRun);
 }
 export {};

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>[];
+};