narraleaf-react 0.8.6 → 0.9.0-beta.1

package/README.md

@@ -123,11 +123,7 @@ npm install narraleaf-react
   - [Player](https://react.narraleaf.com/documentation/player/player)
   - [GameProviders](https://react.narraleaf.com/documentation/player/game-providers)
   - Hooks
-    - [useGame](https://react.narraleaf.com/documentation/player/hooks/useGame)
-    - [usePreferences](https://react.narraleaf.com/documentation/player/hooks/usePreferences)
-    - [useRouter](https://react.narraleaf.com/documentation/player/hooks/useRouter)
-    - [useDialog](https://react.narraleaf.com/documentation/player/hooks/useDialog)
-  - [Page Router](https://react.narraleaf.com/documentation/player/page-router)
+  - [LayoutRouter](https://react.narraleaf.com/documentation/player/page-router)
   - [Dialog](https://react.narraleaf.com/documentation/player/dialog)
   - [Notification](https://react.narraleaf.com/documentation/player/notification)
   - [Menu](https://react.narraleaf.com/documentation/player/menu)

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

@@ -89,7 +89,7 @@ export declare const SoundActionTypes: {
     readonly resume: "sound:resume";
 };
 export type SoundActionContentType = {
-    [K in typeof SoundActionTypes[keyof typeof SoundActionTypes]]: K extends "sound:play" ? [FadeOptions] : K extends "sound:stop" ? [FadeOptions] : K extends "sound:setVolume" ? [volumn: number, duration: number] : K extends "sound:setRate" ? [number] : K extends "sound:pause" ? [FadeOptions] : K extends "sound:resume" ? [FadeOptions] : any;
+    [K in typeof SoundActionTypes[keyof typeof SoundActionTypes]]: K extends "sound:play" ? [FadeOptions] : K extends "sound:stop" ? [FadeOptions] : K extends "sound:setVolume" ? [volume: number, duration: number] : K extends "sound:setRate" ? [number] : K extends "sound:pause" ? [FadeOptions] : K extends "sound:resume" ? [FadeOptions] : any;
 };
 export declare const ControlActionTypes: {
     readonly action: "control:action";

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

@@ -33,7 +33,12 @@ export declare class SceneAction<T extends typeof SceneActionTypes[keyof typeof
         node: ContentNode<any> | null;
         wait?: import("../../gameTypes").StackModelWaiting | null;
     } | Awaitable<CalledActionResult, any>;
-    static initBackgroundMusic(scene: Scene, exposed: ExposedState[ExposedStateType.scene]): void;
+    /**
+     * Initialize background music for the target scene.
+     * Waits until the previous BGM has completely faded out (if any) before
+     * resolving, ensuring seamless audio transition when jumping between scenes.
+     */
+    static initBackgroundMusic(scene: Scene, exposed: ExposedState[ExposedStateType.scene]): Promise<void>;
     static createSceneSnapshot(scene: Scene, state: GameState): SceneSnapshot;
     static restoreSceneSnapshot(snapshot: SceneSnapshot, state: GameState): void;
     applyTransition(gameState: GameState, transition: ImageTransition, injection: ActionExecutionInjection): Awaitable<CalledActionResult, CalledActionResult>;

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

@@ -1 +1,2 @@
 export { Gallery } from "../elements/built-in/Gallery";
+export { DevTools } from "../elements/built-in/DevTools";

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

@@ -8,6 +8,8 @@ import { GameConfig, SavedGame, NotificationToken, SavedGameMetaData } from "../
 import type { LayoutRouter } from "../../../game/player/lib/PageRouter/router";
 import { KeyBindingType, WebKeyboardKey } from "../game/types";
 import { KeyBindingValue } from "../game/keyMap";
+import { SoundType } from "../elements/sound";
+import { StorableType } from "../elements/persistent/type";
 export * from "../elements/type";
-export type { GameHistory, IGamePluginRegistry, LiveGameEventToken, Origins, ServiceHandlerCtx, TransformDefinitions, GameConfig, SavedGame, NotificationToken, SavedGameMetaData, LayoutRouter, KeyBindingValue, WebKeyboardKey, };
-export { KeyBindingType, };
+export type { GameHistory, IGamePluginRegistry, LiveGameEventToken, Origins, ServiceHandlerCtx, TransformDefinitions, GameConfig, SavedGame, NotificationToken, SavedGameMetaData, LayoutRouter, KeyBindingValue, WebKeyboardKey, StorableType, };
+export { KeyBindingType, SoundType, };

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

@@ -0,0 +1,12 @@
+import { ControlAction } from "../../action/actions/controlAction";
+import { Chained, Proxied } from "../../action/chain";
+import { LogicAction } from "../../game";
+import { DynamicPersistent, Persistent } from "../persistent";
+export declare class DevTools {
+    static getActionId(action: LogicAction.Actions): string;
+    static setActionId(action: LogicAction.Actions, id: string): LogicAction.Actions;
+    static chainToActions(chain: Proxied<LogicAction.GameElement, Chained<LogicAction.Actions>>): LogicAction.Actions[];
+    static wrapAction(action: LogicAction.Actions[] | Proxied<LogicAction.GameElement, Chained<LogicAction.Actions>>): ControlAction;
+    static getNamespaceName(persistent: Persistent<any>): string;
+    static DynamicPersistent: typeof DynamicPersistent;
+}

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

@@ -1 +1,2 @@
 export { Gallery } from "./Gallery";
+export { DevTools } from "./DevTools";

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

@@ -7,9 +7,14 @@ export declare class Namespace<T extends NameSpaceContent<keyof T>> {
     get<Key extends keyof T = any>(key: Key): T[Key];
     equals<Key extends keyof T = any>(key: Key, value: T[Key]): boolean;
     assign(values: Partial<T>): this;
+    has(key: keyof T): boolean;
+    keys(): (keyof T)[];
+    values(): T[keyof T][];
+    entries(): [keyof T, T[keyof T]][];
     reset(): this;
 }
 export declare class Storable {
+    static createNamespace<T extends NameSpaceContent<keyof T>>(name: string, initContent: T, key?: string): Namespace<T>;
     addNamespace<T extends NameSpaceContent<keyof T>>(namespace: Namespace<T>): this | undefined;
     getNamespace<T extends NameSpaceContent<keyof T> = any>(key: string): Namespace<T>;
     setNamespace<T extends NameSpaceContent<keyof T> = any>(key: string, namespace: Namespace<T>): this;

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

@@ -1,3 +1,4 @@
 export type StorableData<K extends string = string> = {
     [key in K]: number | boolean | string | StorableData | StorableData[] | undefined | null | Date;
 };
+export type StorableType = BaseStorableType | Record<string, BaseStorableType> | Array<BaseStorableType>;

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

@@ -31,7 +31,6 @@ export interface ISceneUserConfig {
 }
 export type JumpConfig = {
     transition: ImageTransition;
-    unloadScene: boolean;
 };
 type ChainableAction = Proxied<LogicAction.GameElement, Chained<LogicAction.Actions>> | LogicAction.Actions;
 type ChainedScene = Proxied<Scene, Chained<LogicAction.Actions>>;

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

@@ -1,4 +1,4 @@
-import { Sound, SoundType } from "../../nlcore/elements/sound";
+import { Sound as SoundElement, SoundType } from "../../nlcore/elements/sound";
 import { FadeOptions } from "../../nlcore/elements/type";
 import { Awaitable } from "../../../util/data";
 import { GameState } from "../gameState";
@@ -14,37 +14,35 @@ export type AudioManagerDataRaw = {
 export declare class AudioManager {
     private gameState;
     private state;
-    private tasks;
-    private groups;
+    private channels;
+    private channelVolumes;
+    private globalVolume;
+    private sound;
+    private ready;
+    private isReady;
     constructor(gameState: GameState);
-    play(sound: Sound, options?: FadeOptions): Awaitable<void>;
-    stop(sound: Sound, duration?: number): Awaitable<void>;
-    setVolume(sound: Sound, volume: number, duration?: number): Awaitable<void>;
-    pause(sound: Sound, duration?: number): Awaitable<void>;
-    resume(sound: Sound, duration?: number): Awaitable<void>;
-    setRate(sound: Sound, rate: number): Awaitable<void>;
-    getPosition(sound: Sound): number;
-    isPlaying(sound: Sound): boolean;
+    /**
+     * Must be called ONCE on the client side to prepare audio subsystem.
+     * Doing it here avoids "AudioContext is not defined" on the server.
+     */
+    initialize(): void;
+    play(sound: SoundElement, options?: FadeOptions): Awaitable<void>;
+    stop(sound: SoundElement, duration?: number): Awaitable<void>;
+    setVolume(sound: SoundElement, volume: number, duration?: number): Awaitable<void>;
+    pause(sound: SoundElement, duration?: number): Awaitable<void>;
+    resume(sound: SoundElement, duration?: number): Awaitable<void>;
+    setRate(sound: SoundElement, rate: number): Awaitable<void>;
+    getPosition(sound: SoundElement): number;
+    isPlaying(sound: SoundElement): boolean;
     toData(): AudioManagerDataRaw;
     fromData(data: AudioManagerDataRaw, elementMap: Map<string, LogicAction.GameElement>): this;
-    soundFromData(sound: Sound, data: AudioDataRaw): void;
-    isManaged(sound: Sound): boolean;
+    soundFromData(sound: SoundElement, data: AudioDataRaw): void;
+    isManaged(sound: SoundElement): boolean;
     reset(): void;
     setGroupVolume(type: SoundType, volume: number): void;
     setGlobalVolume(volume: number): void;
     getGlobalVolume(): number;
     getGroupVolume(type: SoundType): number;
+    destroy(): void;
     private setupGroupVolume;
-    private initSound;
-    private pushTask;
-    private getState;
-    private abortTask;
-    private fadeTo;
-    private stopSound;
-    private pauseSound;
-    private resumeSound;
-    private getHowlConfig;
-    private createTask;
-    private wrapTask;
-    private applyEffectiveVolume;
 }