@almadar/ui 2.14.0 → 2.15.0

package/dist/components/organisms/game/BattleBoard.d.ts

@@ -0,0 +1,175 @@
+/**
+ * BattleBoard
+ *
+ * Core rendering organism for turn-based battles.
+ *
+ * This is a **controlled-only** component: all game state (units, phase,
+ * turn, gameResult, selectedUnitId) must be provided via the `entity` prop.
+ * User interactions are communicated via event bus emissions so the parent
+ * (typically an Orbital trait or the `useBattleState` hook) can manage
+ * state transitions.
+ *
+ * For a self-managing version, use `UncontrolledBattleBoard` which
+ * composes this component with the `useBattleState` hook.
+ *
+ * Animation-only state (movement interpolation, screen shake, hover) is
+ * always managed locally.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { EntityDisplayProps } from '../types';
+import type { IsometricTile, IsometricFeature } from './types/isometric';
+import type { ResolvedFrame } from './types/spriteAnimation';
+/** Battle phases an encounter walks through */
+export type BattlePhase = 'observation' | 'selection' | 'movement' | 'action' | 'enemy_turn' | 'game_over';
+/** A unit participating in battle */
+export interface BattleUnit {
+    id: string;
+    name: string;
+    unitType?: string;
+    heroId?: string;
+    sprite?: string;
+    /** Optional sprite sheet for animation (null = use static sprite) */
+    spriteSheet?: {
+        se: string;
+        sw: string;
+        frameWidth: number;
+        frameHeight: number;
+    } | null;
+    team: 'player' | 'enemy';
+    position: {
+        x: number;
+        y: number;
+    };
+    health: number;
+    maxHealth: number;
+    movement: number;
+    attack: number;
+    defense: number;
+    traits?: {
+        name: string;
+        currentState: string;
+        states: string[];
+        cooldown?: number;
+    }[];
+}
+/** Minimal tile for map generation */
+export interface BattleTile {
+    x: number;
+    y: number;
+    terrain: string;
+    terrainSprite?: string;
+}
+/** Entity prop containing all board data.
+ *
+ * BattleBoard is **controlled-only**: all game-state fields (`units`, `phase`,
+ * `turn`, `gameResult`, `selectedUnitId`) must be provided.  Mutations are
+ * communicated via event bus emissions — the component never calls `setState`
+ * for game-logic values.
+ *
+ * For a self-managing variant, use `UncontrolledBattleBoard`.
+ *
+ * Animation-only state (`movingPositions`, `isShaking`, `hoveredTile`) is
+ * always managed locally.
+ */
+export interface BattleEntity {
+    id: string;
+    tiles: IsometricTile[];
+    features?: IsometricFeature[];
+    boardWidth?: number;
+    boardHeight?: number;
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+        effects?: Record<string, string>;
+    };
+    backgroundImage?: string;
+    /** Current unit state. */
+    units: BattleUnit[];
+    /** Current battle phase. */
+    phase: BattlePhase;
+    /** Current turn number. */
+    turn: number;
+    /** Game result. `null` = still in progress. */
+    gameResult: 'victory' | 'defeat' | null;
+    /** Currently selected unit ID. */
+    selectedUnitId: string | null;
+}
+/** Context exposed to render-prop slots */
+export interface BattleSlotContext {
+    phase: BattlePhase;
+    turn: number;
+    selectedUnit: BattleUnit | null;
+    hoveredUnit: BattleUnit | null;
+    playerUnits: BattleUnit[];
+    enemyUnits: BattleUnit[];
+    gameResult: 'victory' | 'defeat' | null;
+    onEndTurn: () => void;
+    onCancel: () => void;
+    onReset: () => void;
+    attackTargets: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Resolve screen position of a tile for overlays */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+}
+export interface BattleBoardProps extends Omit<EntityDisplayProps, 'entity'> {
+    /** Entity containing all board data */
+    entity: BattleEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** Unit draw-size multiplier */
+    unitScale?: number;
+    /** Header area -- receives battle context */
+    header?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Sidebar content (combat log, unit roster, etc.) */
+    sidebar?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Floating action buttons */
+    actions?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Floating overlays above the canvas (damage popups, tooltips) */
+    overlay?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Game-over screen overlay */
+    gameOverOverlay?: (ctx: BattleSlotContext) => React.ReactNode;
+    /** Called when a unit attacks another */
+    onAttack?: (attacker: BattleUnit, target: BattleUnit, damage: number) => void;
+    /** Called when battle ends */
+    onGameEnd?: (result: 'victory' | 'defeat') => void;
+    /** Called after a unit moves */
+    onUnitMove?: (unit: BattleUnit, to: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Custom combat damage calculator */
+    calculateDamage?: (attacker: BattleUnit, target: BattleUnit) => number;
+    onDrawEffects?: (ctx: CanvasRenderingContext2D, timestamp: number) => void;
+    hasActiveEffects?: boolean;
+    effectSpriteUrls?: string[];
+    resolveUnitFrame?: (unitId: string) => ResolvedFrame | null;
+    /** Emits UI:{tileClickEvent} with { x, y } on tile click */
+    tileClickEvent?: string;
+    /** Emits UI:{unitClickEvent} with { unitId } on unit click */
+    unitClickEvent?: string;
+    /** Emits UI:{endTurnEvent} with {} on end turn */
+    endTurnEvent?: string;
+    /** Emits UI:{cancelEvent} with {} on cancel */
+    cancelEvent?: string;
+    /** Emits UI:{gameEndEvent} with { result } on game end */
+    gameEndEvent?: string;
+    /** Emits UI:{playAgainEvent} with {} on play again / reset */
+    playAgainEvent?: string;
+    /** Emits UI:{attackEvent} with { attackerId, targetId, damage } on attack */
+    attackEvent?: string;
+    className?: string;
+}
+export declare function BattleBoard({ entity, scale, unitScale, header, sidebar, actions, overlay, gameOverOverlay, onAttack, onGameEnd, onUnitMove, calculateDamage, onDrawEffects, hasActiveEffects, effectSpriteUrls, resolveUnitFrame, tileClickEvent, unitClickEvent, endTurnEvent, cancelEvent, gameEndEvent, playAgainEvent, attackEvent, className, }: BattleBoardProps): React.JSX.Element;
+export declare namespace BattleBoard {
+    var displayName: string;
+}
+export default BattleBoard;

package/dist/components/organisms/game/CanvasEffect.d.ts

@@ -0,0 +1,68 @@
+/**
+ * CanvasEffect Component
+ *
+ * Renders animated visual effects using a `<canvas>` element with
+ * sprite-based particles, frame-sequence animations, and overlays.
+ * This is a render-ui pattern that can be placed in any slot —
+ * it renders on top of whatever occupies that slot.
+ *
+ * Pattern: canvas-effect
+ *
+ * When an EffectAssetManifest is provided (via assetManifest prop),
+ * the component uses the full particle engine with tinted sprites.
+ * Without a manifest, it falls back to emoji-based rendering.
+ *
+ * **State categories (closed-circuit compliant):**
+ * - Configuration (actionType, position, duration, manifest) → received via props
+ * - Animation state (particles, shake, flash, RAF loop, phase timers) → local only
+ * - Completion event → emitted via `useEventBus()` for trait integration
+ *
+ * This is an **ephemeral fire-and-forget** animation component.  All
+ * internal state is rendering-only (particle physics, screen shake decay,
+ * flash alpha, emoji phase timers).  No game logic lives here.
+ *
+ * @packageDocumentation
+ */
+import * as React from 'react';
+import type { CombatActionType, EffectAssetManifest } from './types/effects';
+export type { CombatActionType } from './types/effects';
+export type { EffectAssetManifest } from './types/effects';
+export interface CanvasEffectProps {
+    /** The type of combat action to visualise */
+    actionType: CombatActionType;
+    /** Screen-space X position (center of the effect) */
+    x: number;
+    /** Screen-space Y position (center of the effect) */
+    y: number;
+    /** Duration in ms before auto-dismiss (default 2000 for canvas, 800 for emoji) */
+    duration?: number;
+    /** Optional intensity multiplier (1 = normal, 2 = double size/brightness) */
+    intensity?: number;
+    /** Callback when the effect animation completes */
+    onComplete?: () => void;
+    /** Declarative event: emits UI:{completeEvent} when the effect animation completes */
+    completeEvent?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: Error | null;
+    /** Sprite URL for the effect (emoji fallback mode).
+     *  When set without assetManifest, renders this image instead of emoji. */
+    effectSpriteUrl?: string;
+    /** Base URL for remote assets. Prepended to relative effectSpriteUrl paths. */
+    assetBaseUrl?: string;
+    /** Full effect asset manifest for the sprite particle engine.
+     *  When provided, enables the canvas-based particle system. */
+    assetManifest?: EffectAssetManifest;
+    /** Canvas width (default 400) */
+    width?: number;
+    /** Canvas height (default 300) */
+    height?: number;
+}
+export declare function CanvasEffect(props: CanvasEffectProps): React.JSX.Element | null;
+export declare namespace CanvasEffect {
+    var displayName: string;
+}
+export default CanvasEffect;

package/dist/components/organisms/game/CastleBoard.d.ts

@@ -0,0 +1,85 @@
+/**
+ * CastleBoard
+ *
+ * Self-contained castle / base-management game board organism. Encapsulates all
+ * isometric canvas rendering, hover/selection state, and slot-based layout.
+ * Designed to be consumed by CastleTemplate (thin wrapper) or embedded directly
+ * in any page that needs an isometric castle view.
+ *
+ * Accepts an `entity` prop conforming to `CastleEntity` and optional declarative
+ * event props (`featureClickEvent`, `unitClickEvent`, `tileClickEvent`) that
+ * emit through the Orbital event bus.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from './types/isometric';
+/** Entity shape consumed by CastleBoard */
+export interface CastleEntity {
+    id: string;
+    tiles: IsometricTile[];
+    features?: IsometricFeature[];
+    units?: IsometricUnit[];
+    assetManifest?: {
+        baseUrl: string;
+        terrains?: Record<string, string>;
+        units?: Record<string, string>;
+        features?: Record<string, string>;
+    };
+    backgroundImage?: string;
+}
+/** Context exposed to render-prop slots */
+export interface CastleSlotContext {
+    /** Currently hovered tile coordinates (null when not hovering) */
+    hoveredTile: {
+        x: number;
+        y: number;
+    } | null;
+    /** Feature that sits on the hovered tile, if any */
+    hoveredFeature: IsometricFeature | null;
+    /** Unit that sits on the hovered tile, if any */
+    hoveredUnit: IsometricUnit | null;
+    /** The clicked feature (e.g. building) for detail view */
+    selectedFeature: IsometricFeature | null;
+    /** Clear selected feature */
+    clearSelection: () => void;
+    /** Resolve screen position for overlay positioning */
+    tileToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    /** Canvas scale */
+    scale: number;
+}
+export interface CastleBoardProps {
+    /** Castle entity data */
+    entity: CastleEntity;
+    /** Canvas render scale */
+    scale?: number;
+    /** Top bar / header */
+    header?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Side panel content (buildings list, recruit tab, garrison tab) */
+    sidePanel?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Canvas overlay (hover tooltips, etc.) */
+    overlay?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Bottom bar (income summary, etc.) */
+    footer?: (ctx: CastleSlotContext) => React.ReactNode;
+    /** Called when a feature (building) is clicked */
+    onFeatureClick?: (feature: IsometricFeature) => void;
+    /** Called when a unit is clicked */
+    onUnitClick?: (unit: IsometricUnit) => void;
+    /** Called when any tile is clicked */
+    onTileClick?: (x: number, y: number) => void;
+    /** Event name to emit via event bus when a feature is clicked (emits UI:{featureClickEvent}) */
+    featureClickEvent?: string;
+    /** Event name to emit via event bus when a unit is clicked (emits UI:{unitClickEvent}) */
+    unitClickEvent?: string;
+    /** Event name to emit via event bus when a tile is clicked (emits UI:{tileClickEvent}) */
+    tileClickEvent?: string;
+    className?: string;
+}
+export declare function CastleBoard({ entity, scale, header, sidePanel, overlay, footer, onFeatureClick, onUnitClick, onTileClick, featureClickEvent, unitClickEvent, tileClickEvent, className, }: CastleBoardProps): React.JSX.Element;
+export declare namespace CastleBoard {
+    var displayName: string;
+}
+export default CastleBoard;

package/dist/components/organisms/game/CombatLog.d.ts

@@ -0,0 +1,2 @@
+export { CombatLog } from '../../molecules/game/CombatLog';
+export type { CombatLogProps, CombatEvent, CombatLogEventType } from '../../molecules/game/CombatLog';

package/dist/components/organisms/game/DialogueBox.d.ts

@@ -0,0 +1,2 @@
+export { DialogueBox } from '../../molecules/game/DialogueBox';
+export type { DialogueBoxProps, DialogueNode, DialogueChoice } from '../../molecules/game/DialogueBox';

package/dist/components/organisms/game/GameAudioProvider.d.ts

@@ -0,0 +1,47 @@
+/**
+ * GameAudioProvider
+ *
+ * Context provider that wires the audio system to the Almadar event bus.
+ * Wrap your game organism with this provider, then emit:
+ *
+ *   emit('UI:PLAY_SOUND', { key: 'footstep' })
+ *
+ * from anywhere inside the tree and the corresponding sound will play.
+ *
+ * The provider also exposes `muted`/`setMuted` and `masterVolume`/
+ * `setMasterVolume` via the `GameAudioContext` for toggle buttons.
+ *
+ * Closed-circuit props (`className`, `isLoading`, `error`, `entity`) are
+ * accepted but intentionally unused — the provider renders only its children.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import { type AudioManifest, type GameAudioControls } from './hooks/useGameAudio';
+export type GameAudioContextValue = Pick<GameAudioControls, 'muted' | 'setMuted' | 'masterVolume' | 'setMasterVolume' | 'play' | 'playMusic' | 'stopMusic'>;
+export declare const GameAudioContext: React.Context<GameAudioContextValue | null>;
+/**
+ * Access the game audio context.
+ * Must be called from within a `<GameAudioProvider>` tree.
+ */
+export declare function useGameAudioContext(): GameAudioContextValue;
+export interface GameAudioProviderProps {
+    /** Sound manifest — keys mapped to SoundEntry definitions */
+    manifest: AudioManifest;
+    /** Base URL prepended to all sound paths (default '') */
+    baseUrl?: string;
+    /** Children to render */
+    children: React.ReactNode;
+    /** Initial muted state */
+    initialMuted?: boolean;
+    /** Closed-circuit props (unused, accepted for runtime compatibility) */
+    className?: string;
+    isLoading?: boolean;
+    error?: Error | null;
+    entity?: string;
+}
+export declare function GameAudioProvider({ manifest, baseUrl, children, initialMuted, }: GameAudioProviderProps): React.JSX.Element;
+export declare namespace GameAudioProvider {
+    var displayName: string;
+}
+export default GameAudioProvider;

package/dist/components/organisms/game/GameAudioToggle.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GameAudioToggle
+ *
+ * A small mute/unmute button for game HUDs.
+ * Must be rendered inside a <GameAudioProvider> tree.
+ *
+ * Shows 🔊 when sound is on and 🔇 when muted.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+export interface GameAudioToggleProps {
+    /** Button size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+    /** Loading state (passed through) */
+    isLoading?: boolean;
+    /** Error state (passed through) */
+    error?: Error | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+}
+export declare function GameAudioToggle({ size, className, }: GameAudioToggleProps): React.JSX.Element;
+export declare namespace GameAudioToggle {
+    var displayName: string;
+}
+export default GameAudioToggle;

package/dist/components/organisms/game/GameCanvas3D.d.ts

@@ -0,0 +1,181 @@
+/**
+ * GameCanvas3D
+ *
+ * 3D game canvas component using Three.js.
+ * Mirrors the IsometricCanvas API for easy migration.
+ *
+ * **State categories (closed-circuit compliant):**
+ * - All game data (tiles, units, features, selection, validMoves) → received via props
+ * - Rendering state (hoveredTile, internalError, asset loading, camera) → local only
+ * - Events → emitted via `useGameCanvas3DEvents()` hook for trait integration
+ *
+ * This component is a **pure 3D renderer** — it holds no game logic state.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import * as THREE from 'three';
+import { AssetLoader } from './three/loaders/AssetLoader';
+import type { IsometricTile, IsometricUnit, IsometricFeature } from './types/isometric';
+import './GameCanvas3D.css';
+export type { IsometricTile, IsometricUnit, IsometricFeature };
+/** Game event for canvas display */
+export interface GameEvent {
+    id: string;
+    type: string;
+    x: number;
+    z?: number;
+    y?: number;
+    message?: string;
+}
+/** Camera mode for 3D view */
+export type CameraMode = 'isometric' | 'perspective' | 'top-down';
+/** Map orientation */
+export type MapOrientation = 'standard' | 'rotated';
+/** Overlay control */
+export type OverlayControl = 'default' | 'hidden' | 'minimap';
+/** Unit animation state */
+export type UnitAnimationState = 'idle' | 'walk' | 'attack' | 'hurt' | 'die';
+/** Props for GameCanvas3D component */
+export interface GameCanvas3DProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Children to render inside the 3D canvas (e.g., physics objects, custom meshes) */
+    children?: React.ReactNode;
+    /** Loading state indicator */
+    isLoading?: boolean;
+    /** Error state */
+    error?: string | null;
+    /** Entity name for schema-driven auto-fetch */
+    entity?: string;
+    /** Array of tiles to render */
+    tiles?: IsometricTile[];
+    /** Array of units to render */
+    units?: IsometricUnit[];
+    /** Array of features to render */
+    features?: IsometricFeature[];
+    /** Array of events to display */
+    events?: Array<GameEvent>;
+    /** Fog of war data */
+    fogOfWar?: boolean[][];
+    /** Map orientation */
+    orientation?: MapOrientation;
+    /** Camera mode */
+    cameraMode?: CameraMode;
+    /** Show grid */
+    showGrid?: boolean;
+    /** Show coordinates overlay */
+    showCoordinates?: boolean;
+    /** Show tile information */
+    showTileInfo?: boolean;
+    /** Overlay control mode */
+    overlay?: OverlayControl;
+    /** Enable shadows */
+    shadows?: boolean;
+    /** Background color */
+    backgroundColor?: string;
+    /** Callback when a tile is clicked */
+    onTileClick?: (tile: IsometricTile, event: React.MouseEvent) => void;
+    /** Callback when a unit is clicked */
+    onUnitClick?: (unit: IsometricUnit, event: React.MouseEvent) => void;
+    /** Callback when a feature is clicked */
+    onFeatureClick?: (feature: IsometricFeature, event: React.MouseEvent) => void;
+    /** Callback when canvas is clicked (background) */
+    onCanvasClick?: (event: React.MouseEvent) => void;
+    /** Callback when mouse moves over a tile */
+    onTileHover?: (tile: IsometricTile | null, event: React.MouseEvent) => void;
+    /** Callback for unit animation state change */
+    onUnitAnimation?: (unitId: string, state: string) => void;
+    /** Asset loader instance (uses global singleton if not provided) */
+    assetLoader?: AssetLoader;
+    /** Custom tile renderer component */
+    tileRenderer?: React.FC<{
+        tile: IsometricTile;
+        position: [number, number, number];
+    }>;
+    /** Custom unit renderer component */
+    unitRenderer?: React.FC<{
+        unit: IsometricUnit;
+        position: [number, number, number];
+    }>;
+    /** Custom feature renderer component */
+    featureRenderer?: React.FC<{
+        feature: IsometricFeature;
+        position: [number, number, number];
+    }>;
+    /** URLs to preload */
+    preloadAssets?: string[];
+    /** Declarative event: tile click */
+    tileClickEvent?: string;
+    /** Declarative event: unit click */
+    unitClickEvent?: string;
+    /** Declarative event: feature click */
+    featureClickEvent?: string;
+    /** Declarative event: canvas click */
+    canvasClickEvent?: string;
+    /** Declarative event: tile hover */
+    tileHoverEvent?: string;
+    /** Declarative event: tile leave */
+    tileLeaveEvent?: string;
+    /** Declarative event: unit animation */
+    unitAnimationEvent?: string;
+    /** Declarative event: camera change */
+    cameraChangeEvent?: string;
+    /** Loading message */
+    loadingMessage?: string;
+    /** Whether to use instancing for tiles */
+    useInstancing?: boolean;
+    /** Valid move positions */
+    validMoves?: Array<{
+        x: number;
+        z: number;
+    }>;
+    /** Attack target positions */
+    attackTargets?: Array<{
+        x: number;
+        z: number;
+    }>;
+    /** Selected tile IDs */
+    selectedTileIds?: string[];
+    /** Selected unit ID */
+    selectedUnitId?: string | null;
+}
+/** Imperative handle for GameCanvas3D */
+export interface GameCanvas3DHandle {
+    /** Get current camera position */
+    getCameraPosition: () => THREE.Vector3 | null;
+    /** Set camera position */
+    setCameraPosition: (x: number, y: number, z: number) => void;
+    /** Look at a specific point */
+    lookAt: (x: number, y: number, z: number) => void;
+    /** Reset camera to default position */
+    resetCamera: () => void;
+    /** Take a screenshot */
+    screenshot: () => string | null;
+    /** Export current view as data */
+    export: () => {
+        tiles: IsometricTile[];
+        units: IsometricUnit[];
+        features: IsometricFeature[];
+    };
+}
+/**
+ * GameCanvas3D Component
+ *
+ * 3D game canvas that mirrors the IsometricCanvas API.
+ * Uses Three.js and React Three Fiber for rendering.
+ *
+ * @example
+ * ```tsx
+ * <GameCanvas3D
+ *   tiles={tiles}
+ *   units={units}
+ *   features={features}
+ *   cameraMode="isometric"
+ *   tileClickEvent="TILE_SELECTED"
+ *   onTileClick={(tile) => console.log('Clicked:', tile)}
+ * />
+ * ```
+ */
+export declare const GameCanvas3D: React.ForwardRefExoticComponent<GameCanvas3DProps & React.RefAttributes<GameCanvas3DHandle>>;
+export default GameCanvas3D;

package/dist/components/organisms/game/GameHud.d.ts

@@ -0,0 +1,2 @@
+export { GameHud } from '../../molecules/game/GameHud';
+export type { GameHudProps, GameHudStat, GameHudElement } from '../../molecules/game/GameHud';

package/dist/components/organisms/game/GameMenu.d.ts

@@ -0,0 +1,2 @@
+export { GameMenu } from '../../molecules/game/GameMenu';
+export type { GameMenuProps, MenuOption } from '../../molecules/game/GameMenu';

package/dist/components/organisms/game/GameOverScreen.d.ts

@@ -0,0 +1,2 @@
+export { GameOverScreen } from '../../molecules/game/GameOverScreen';
+export type { GameOverScreenProps, GameOverStat, GameOverAction } from '../../molecules/game/GameOverScreen';

package/dist/components/organisms/game/InventoryPanel.d.ts

@@ -0,0 +1,2 @@
+export { InventoryPanel } from '../../molecules/game/InventoryPanel';
+export type { InventoryPanelProps, InventoryItem } from '../../molecules/game/InventoryPanel';

package/dist/components/organisms/game/IsometricCanvas.d.ts

@@ -0,0 +1,3 @@
+export { IsometricCanvas } from '../../molecules/game/IsometricCanvas';
+export { default } from '../../molecules/game/IsometricCanvas';
+export type { IsometricCanvasProps } from '../../molecules/game/IsometricCanvas';

package/dist/components/organisms/game/PlatformerCanvas.d.ts

@@ -0,0 +1,2 @@
+export { PlatformerCanvas } from '../../molecules/game/PlatformerCanvas';
+export type { PlatformerCanvasProps, PlatformerPlatform, PlatformerPlayer } from '../../molecules/game/PlatformerCanvas';