@lute-lang/player-web 0.0.0-stage → 0.41.0

package/dist/ui/screens/save-load.d.ts

@@ -0,0 +1,14 @@
+import type { ScreenModel, SlotInfo } from "@lute-lang/player";
+import type { Theme } from "../../engine/types.js";
+import { ScreenView, type EmitAction } from "./common.js";
+/** Number of normal slots displayed per page. */
+export declare const SLOTS_PER_PAGE = 6;
+/** Return the six slots for a page, including empty placeholders. */
+export declare function pageSlots(slots: ReadonlyArray<SlotInfo>, page: number): ReadonlyArray<SlotInfo | undefined>;
+/** Save/load slot grid with thumbnails and paging. */
+export declare class SaveLoadScreen extends ScreenView {
+    constructor(model: Extract<ScreenModel, {
+        _tag: "SaveLoad";
+    }>, theme: Theme, emit: EmitAction);
+    private slot;
+}

package/dist/ui/screens/settings-screen.d.ts

@@ -0,0 +1 @@
+export { SettingsScreen } from "./settings.js";

package/dist/ui/screens/settings.d.ts

@@ -0,0 +1,13 @@
+import type { ScreenModel } from "@lute-lang/player";
+import type { Theme } from "../../engine/types.js";
+import { ScreenView, type EmitAction } from "./common.js";
+/** Settings editor with live values emitted on every control change. */
+export declare class SettingsScreen extends ScreenView {
+    private readonly settings;
+    private readonly sample;
+    constructor(model: Extract<ScreenModel, {
+        _tag: "Settings";
+    }>, theme: Theme, emit: EmitAction);
+    private row;
+    private volumeSlider;
+}

package/dist/ui/screens/title.d.ts

@@ -0,0 +1 @@
+export { TitleScreen } from "./common.js";

package/dist/ui/ui.d.ts

@@ -0,0 +1,65 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { Container, Texture } from "pixi.js";
+import type { PlayerAction, ScreenModel } from "@lute-lang/player";
+import type { WorldShape, Theme } from "../engine/types.js";
+/** UI renderer service contract. */
+export interface UiShape {
+    readonly show: (screen: ScreenModel) => Effect.Effect<void>;
+    readonly hide: Effect.Effect<void>;
+    readonly actions: Stream.Stream<PlayerAction>;
+    readonly setTheme: (theme: Theme) => void;
+}
+/** UI context service key. */
+export declare const UiTag: Context.Service<UiShape, UiShape>;
+/** Design-space screens, overlays and HUD; the application owns viewport scaling. */
+export declare class Ui implements UiShape {
+    readonly actions: Stream.Stream<PlayerAction>;
+    private readonly root;
+    private theme;
+    private readonly textureFor;
+    private current;
+    private base;
+    private overlay;
+    private hud;
+    private hudState;
+    private design;
+    private titleName;
+    private push;
+    constructor(root: Container, theme: Theme, _world?: WorldShape, textureFor?: (file: string) => Texture | undefined);
+    /** Replace a screen or the topmost modal without leaving old scene children. */
+    show(screen: ScreenModel): Effect.Effect<void>;
+    /** Close a modal back to its base screen, or remove the full screen for gameplay. */
+    readonly hide: Effect.Effect<void>;
+    /** Replace theme for future screens. */
+    setTheme(theme: Theme): void;
+    /** Configure the game's design coordinates and binding-supplied title. */
+    setDesign(design: {
+        readonly width: number;
+        readonly height: number;
+    }, title?: string): void;
+    /** Standalone viewport layout; mounted UI inherits the application's letterbox. */
+    resize(viewWidth: number, viewHeight: number): void;
+    /** Render the quick menu independently from modal screen ownership. */
+    showHud(state: {
+        readonly auto: boolean;
+        readonly skip: boolean;
+        readonly hidden?: boolean;
+    }): void;
+    /** Synchronize gameplay chrome without rebuilding controls on every frame. */
+    setPlaying(playing: boolean, state: {
+        readonly auto: boolean;
+        readonly skip: boolean;
+        readonly hidden?: boolean;
+    }): void;
+    /** Whether a screen, rather than the story, owns keyboard focus. */
+    get hasScreen(): boolean;
+    /** Activate a screen button at viewport CSS coordinates before gameplay input. */
+    pointerAction(clientX: number, clientY: number): boolean;
+    /** Route modal closing and focus keys before gameplay input. */
+    handleKey(key: string): boolean;
+    /** Detach display objects without leaving a stale frame or screen remnant. */
+    private disposeLater;
+    private build;
+}
+/** Construct a renderer service on an existing design-space root. */
+export declare function uiLayer(root: Container, theme: Theme, world?: WorldShape): Layer.Layer<UiShape>;

package/dist/ui/widgets/base.d.ts

@@ -0,0 +1,54 @@
+import { Container, Graphics, Text } from "pixi.js";
+import type { Theme } from "../../engine/types.js";
+/** A callback-free focusable scene node used by FocusManager. */
+export interface Focusable {
+    readonly focusable: boolean;
+    focused: boolean;
+    readonly activate: () => void;
+    readonly focusNode: Container;
+    readonly handleKey?: (key: string) => boolean;
+}
+/** Keyboard focus traversal shared by all UI screens. */
+export declare class FocusManager {
+    private readonly items;
+    private index;
+    private ring;
+    /** Register a focusable widget in tab order. */
+    register(item: Focusable): void;
+    /** Remove a widget from traversal. */
+    unregister(item: Focusable): void;
+    /** Move focus by a tab or arrow direction. */
+    move(delta: number): void;
+    handleKey(key: string): boolean;
+    /** Focus a specific registered index. */
+    focus(index: number): void;
+    /** Focus the first available widget. */
+    focusFirst(): void;
+    /** Current focused widget, if any. */
+    get current(): Focusable | undefined;
+    private drawRing;
+}
+/** Base class for interactive Pixi widgets. */
+export declare abstract class Widget extends Container implements Focusable {
+    readonly focusable = true;
+    private hasFocus;
+    protected readonly hit: Graphics;
+    protected theme: Theme;
+    private enabled;
+    constructor(theme: Theme, width: number, height: number);
+    get focused(): boolean;
+    set focused(value: boolean);
+    get focusNode(): Container;
+    /** Set widget availability and pointer interaction. */
+    setEnabled(enabled: boolean): void;
+    /** True when pointer and keyboard activation are accepted. */
+    get isEnabled(): boolean;
+    /** Implement visual activation. */
+    abstract activate(): void;
+    /** Apply hover visuals. */
+    protected setHover(_hovered: boolean): void;
+    /** Update theme colours. */
+    setTheme(theme: Theme): void;
+}
+/** Draw a text label with the active theme. */
+export declare function label(text: string, theme: Theme, size?: number): Text;

package/dist/ui/widgets/button.d.ts

@@ -0,0 +1,15 @@
+import type { Theme } from "../../engine/types.js";
+import { Widget } from "./base.js";
+/** An interactive labelled button with pointer, focus and keyboard states. */
+export declare class Button extends Widget {
+    private readonly background;
+    private readonly caption;
+    private readonly onPress;
+    private hovered;
+    constructor(text: string, theme: Theme, onPress: () => void, icon?: string);
+    /** Invoke the button action when enabled. */
+    activate(): void;
+    protected setHover(hovered: boolean): void;
+    setTheme(theme: Theme): void;
+    private draw;
+}

package/dist/ui/widgets/controls.d.ts

@@ -0,0 +1,47 @@
+import type { Theme } from "../../engine/types.js";
+import { Widget } from "./base.js";
+/** A keyboard and pointer controlled 0–1 slider. */
+export declare class Slider extends Widget {
+    private readonly track;
+    private readonly knob;
+    private readonly onChange;
+    private value;
+    private dragging;
+    private readonly trackWidth;
+    constructor(value: number, theme: Theme, onChange: (value: number) => void, width?: number);
+    /** Current slider value. */
+    get current(): number;
+    /** Set slider value without emitting an event. */
+    setValue(value: number): void;
+    activate(): void;
+    /** Handle left/right/home/end slider keys. */
+    handleKey(key: string): boolean;
+    private setFromPointer;
+    private change;
+    private draw;
+}
+/** A two-state switch. */
+export declare class Toggle extends Widget {
+    private readonly caption;
+    private readonly background;
+    private readonly onChange;
+    private value;
+    constructor(label: string, value: boolean, theme: Theme, onChange: (value: boolean) => void);
+    get current(): boolean;
+    setValue(value: boolean): void;
+    activate(): void;
+    private draw;
+}
+/** A segmented choice control. */
+export declare class Segmented<T extends string> extends Widget {
+    private readonly options;
+    private readonly buttons;
+    private readonly onChange;
+    private value;
+    private readonly background;
+    constructor(options: ReadonlyArray<T>, value: T, theme: Theme, onChange: (value: T) => void);
+    get current(): T;
+    activate(): void;
+    private select;
+    private draw;
+}

package/dist/ui/widgets/focus-manager.d.ts

@@ -0,0 +1 @@
+export { FocusManager, type Focusable } from "./base.js";

package/dist/ui/widgets/index.d.ts

@@ -0,0 +1,4 @@
+export { FocusManager, Widget, type Focusable } from "./base.js";
+export { Button } from "./button.js";
+export { Slider, Toggle, Segmented } from "./controls.js";
+export { ScrollList, Panel, Label, visibleRange } from "./list.js";

package/dist/ui/widgets/label.d.ts

@@ -0,0 +1 @@
+export { Label } from "./list.js";

package/dist/ui/widgets/list.d.ts

@@ -0,0 +1,50 @@
+import { Container, Graphics, Text } from "pixi.js";
+import type { Theme } from "../../engine/types.js";
+import { Widget } from "./base.js";
+/** Virtualized scroll model used by ScrollList and unit tests. */
+export declare function visibleRange(total: number, rowHeight: number, viewportHeight: number, offset: number): {
+    start: number;
+    end: number;
+};
+/** A virtualized, keyboard/pointer/wheel scroll list. */
+export declare class ScrollList<T> extends Widget {
+    private readonly viewport;
+    private readonly content;
+    private readonly scrollbar;
+    private readonly rows;
+    private readonly values;
+    private readonly renderRow;
+    private readonly rowHeight;
+    private readonly viewportHeight;
+    private offset;
+    private dragging;
+    private dragStart;
+    private dragOffset;
+    constructor(values: ReadonlyArray<T>, theme: Theme, renderRow: (value: T, index: number) => Container, rowHeight?: number, viewportHeight?: number, width?: number);
+    /** Current scroll offset in pixels. */
+    get scrollOffset(): number;
+    /** Maximum scroll offset in pixels. */
+    get maxOffset(): number;
+    /** Scroll by a pixel delta. */
+    scrollBy(delta: number): void;
+    /** Set absolute scroll offset and update only visible rows. */
+    setOffset(offset: number): void;
+    /** Handle keyboard list navigation. */
+    handleKey(key: string): boolean;
+    activate(): void;
+    private refresh;
+}
+/** Rounded themed panel used as a screen background. */
+export declare class Panel extends Graphics {
+    readonly panelWidth: number;
+    readonly panelHeight: number;
+    private theme;
+    constructor(width: number, height: number, theme: Theme, radius?: number);
+    /** Repaint the panel with a new theme. */
+    setTheme(theme: Theme): void;
+    private draw;
+}
+/** Themed text label. */
+export declare class Label extends Text {
+    constructor(text: string, theme: Theme, size?: number);
+}

package/dist/ui/widgets/panel.d.ts

@@ -0,0 +1 @@
+export { Panel } from "./list.js";

package/dist/ui/widgets/scroll-list.d.ts

@@ -0,0 +1 @@
+export { ScrollList, visibleRange } from "./list.js";

package/dist/ui/widgets/segmented.d.ts

@@ -0,0 +1 @@
+export { Segmented } from "./controls.js";

package/dist/ui/widgets/slider.d.ts

@@ -0,0 +1 @@
+export { Slider } from "./controls.js";

package/dist/ui/widgets/toggle.d.ts

@@ -0,0 +1 @@
+export { Toggle } from "./controls.js";

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@lute-lang/player-web",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.41.0",
+  "description": "The Lute web visual-novel player: PixiJS 8 renderer, Web Audio, screens and input over @lute-lang/player.",
+  "license": "MIT",
+  "type": "module",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/journeyWorker/lute.git",
+    "directory": "packages/player-web"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun scripts/build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bunx --bun vitest run",
+    "test:browser": "bunx --bun vitest run --config vitest.browser.config.ts",
+    "test:e2e": "bunx --bun playwright test --config playwright.config.ts",
+    "demo": "bun scripts/demo.ts"
+  },
+  "dependencies": {
+    "@lute-lang/player": "0.41.0",
+    "@lute-lang/runtime": "0.41.0",
+    "pixi.js": "8.22.0",
+    "@pixi/sound": "6.0.1"
+  },
+  "peerDependencies": {
+    "effect": "4.0.2",
+    "@effect/platform-browser": "4.0.2"
+  },
+  "devDependencies": {
+    "@effect/platform-browser": "4.0.2",
+    "@effect/vitest": "4.0.2",
+    "@types/bun": "1.4.2",
+    "@vitest/browser-playwright": "5.0.3",
+    "effect": "4.0.2",
+    "playwright": "1.64.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3"
+  }
+}