@almadar/ui 5.76.2 → 5.76.5

package/dist/runtime/index.js

@@ -1124,14 +1124,17 @@ function lazyFamilyIcon(libKey, importer, pick, fallbackName, family) {
   Wrapped.displayName = `Lazy.${libKey}.${fallbackName}`;
   return Wrapped;
 }
+function isComponentLike(v) {
+  return v != null && (typeof v === "function" || typeof v === "object");
+}
 function resolveLucide(name) {
   if (lucideAliases[name]) return lucideAliases[name];
   const pascal = kebabToPascal(name);
   const lucideMap = LucideIcons2;
   const direct = lucideMap[pascal];
-  if (direct && typeof direct === "function") return direct;
+  if (isComponentLike(direct)) return direct;
   const asIs = lucideMap[name];
-  if (asIs && typeof asIs === "function") return asIs;
+  if (isComponentLike(asIs)) return asIs;
   return LucideIcons2.HelpCircle;
 }
 function resolvePhosphor(name, weight, family) {
@@ -1775,12 +1778,13 @@ function resolveIcon(name) {
 }
 function doResolve(name) {
   if (iconAliases[name]) return iconAliases[name];
+  const isComponentLike2 = (v) => v != null && (typeof v === "function" || typeof v === "object");
   const pascalName = kebabToPascal2(name);
   const lucideMap = LucideIcons2;
   const directLookup = lucideMap[pascalName];
-  if (directLookup && typeof directLookup === "object") return directLookup;
+  if (isComponentLike2(directLookup)) return directLookup;
   const asIs = lucideMap[name];
-  if (asIs && typeof asIs === "object") return asIs;
+  if (isComponentLike2(asIs)) return asIs;
   return LucideIcons2.HelpCircle;
 }
 var colorTokenClasses, iconAliases, resolvedCache, sizeClasses, animationClasses, Icon;
@@ -12447,14 +12451,318 @@ var init_useCanvasEffects = __esm({
     "use client";
   }
 });
+function pickPath(entry) {
+  if (Array.isArray(entry.path)) {
+    return entry.path[Math.floor(Math.random() * entry.path.length)];
+  }
+  return entry.path;
+}
+function useGameAudio({
+  manifest,
+  baseUrl = "",
+  initialMuted = false,
+  initialVolume = 1
+}) {
+  const [muted, setMutedState] = useState(initialMuted);
+  const [masterVolume, setMasterVolumeState] = useState(initialVolume);
+  const mutedRef = useRef(muted);
+  const volumeRef = useRef(masterVolume);
+  const manifestRef = useRef(manifest);
+  mutedRef.current = muted;
+  volumeRef.current = masterVolume;
+  manifestRef.current = manifest;
+  const poolsRef = useRef(/* @__PURE__ */ new Map());
+  const getOrCreateElement = useCallback((key) => {
+    const entry = manifestRef.current[key];
+    if (!entry) return null;
+    let pool = poolsRef.current.get(key);
+    if (!pool) {
+      pool = [];
+      poolsRef.current.set(key, pool);
+    }
+    const maxSize = entry.poolSize ?? 1;
+    for (const audio of pool) {
+      if (audio.paused && (audio.ended || audio.currentTime === 0)) {
+        return audio;
+      }
+    }
+    if (pool.length < maxSize) {
+      const src = baseUrl + pickPath(entry);
+      const audio = new Audio(src);
+      audio.loop = entry.loop ?? false;
+      pool.push(audio);
+      return audio;
+    }
+    if (!entry.loop) {
+      let oldest = pool[0];
+      for (const audio of pool) {
+        if (audio.currentTime > oldest.currentTime) {
+          oldest = audio;
+        }
+      }
+      oldest.pause();
+      oldest.currentTime = 0;
+      return oldest;
+    }
+    return null;
+  }, [baseUrl]);
+  const play = useCallback((key) => {
+    if (mutedRef.current) return;
+    const entry = manifestRef.current[key];
+    if (!entry) return;
+    const audio = getOrCreateElement(key);
+    if (!audio) return;
+    audio.volume = Math.min(1, (entry.volume ?? 1) * volumeRef.current);
+    if (!entry.loop) {
+      audio.currentTime = 0;
+    }
+    const promise = audio.play();
+    if (promise) {
+      promise.catch(() => {
+      });
+    }
+  }, [getOrCreateElement]);
+  const stop = useCallback((key) => {
+    const pool = poolsRef.current.get(key);
+    if (!pool) return;
+    for (const audio of pool) {
+      audio.pause();
+      audio.currentTime = 0;
+    }
+  }, []);
+  const currentMusicKeyRef = useRef(null);
+  const currentMusicElRef = useRef(null);
+  const musicFadeRef = useRef(null);
+  const pendingMusicKeyRef = useRef(null);
+  const clearMusicFade = useCallback(() => {
+    if (musicFadeRef.current) {
+      clearInterval(musicFadeRef.current);
+      musicFadeRef.current = null;
+    }
+  }, []);
+  const playMusic = useCallback((key) => {
+    if (key === currentMusicKeyRef.current) return;
+    pendingMusicKeyRef.current = key;
+    const entry = manifestRef.current[key];
+    if (!entry) return;
+    const fadeDurationMs = entry.crossfadeDurationMs ?? 1500;
+    const stepMs = 50;
+    const totalSteps = Math.max(1, fadeDurationMs / stepMs);
+    const targetVolume = Math.min(1, (entry.volume ?? 1) * volumeRef.current);
+    clearMusicFade();
+    const src = baseUrl + (Array.isArray(entry.path) ? entry.path[0] : entry.path);
+    const incoming = new Audio(src);
+    incoming.loop = true;
+    incoming.volume = 0;
+    const outgoing = currentMusicElRef.current;
+    const outgoingStartVol = outgoing?.volume ?? 0;
+    currentMusicKeyRef.current = key;
+    currentMusicElRef.current = incoming;
+    if (!mutedRef.current) {
+      incoming.play().catch(() => {
+        currentMusicKeyRef.current = null;
+        currentMusicElRef.current = outgoing;
+      });
+    }
+    let step = 0;
+    musicFadeRef.current = setInterval(() => {
+      step++;
+      const progress = Math.min(step / totalSteps, 1);
+      incoming.volume = Math.min(1, targetVolume * progress);
+      if (outgoing) {
+        outgoing.volume = Math.max(0, outgoingStartVol * (1 - progress));
+      }
+      if (progress >= 1) {
+        clearMusicFade();
+        if (outgoing) {
+          outgoing.pause();
+          outgoing.src = "";
+        }
+      }
+    }, stepMs);
+  }, [baseUrl, clearMusicFade]);
+  const stopMusic = useCallback((fadeDurationMs = 1e3) => {
+    const outgoing = currentMusicElRef.current;
+    if (!outgoing) return;
+    currentMusicKeyRef.current = null;
+    currentMusicElRef.current = null;
+    pendingMusicKeyRef.current = null;
+    clearMusicFade();
+    const startVolume = outgoing.volume;
+    const stepMs = 50;
+    const totalSteps = Math.max(1, fadeDurationMs / stepMs);
+    let step = 0;
+    musicFadeRef.current = setInterval(() => {
+      step++;
+      const progress = step / totalSteps;
+      outgoing.volume = Math.max(0, startVolume * (1 - progress));
+      if (progress >= 1) {
+        clearMusicFade();
+        outgoing.pause();
+        outgoing.src = "";
+      }
+    }, stepMs);
+  }, [clearMusicFade]);
+  const stopAll = useCallback(() => {
+    for (const pool of poolsRef.current.values()) {
+      for (const audio of pool) {
+        audio.pause();
+        audio.currentTime = 0;
+      }
+    }
+    stopMusic(0);
+  }, [stopMusic]);
+  const setMuted = useCallback((value) => {
+    setMutedState(value);
+    if (value) {
+      for (const [key, pool] of poolsRef.current.entries()) {
+        if (manifestRef.current[key]?.loop) {
+          for (const audio of pool) {
+            if (!audio.paused) audio.pause();
+          }
+        }
+      }
+      currentMusicElRef.current?.pause();
+    } else {
+      for (const [key, pool] of poolsRef.current.entries()) {
+        const entry = manifestRef.current[key];
+        if (entry?.loop && entry?.autostart) {
+          for (const audio of pool) {
+            if (audio.paused) audio.play().catch(() => {
+            });
+          }
+        }
+      }
+      const musicEl = currentMusicElRef.current;
+      if (musicEl) {
+        musicEl.play().catch(() => {
+        });
+      }
+    }
+  }, []);
+  const setMasterVolume = useCallback((volume) => {
+    const clamped = Math.max(0, Math.min(1, volume));
+    setMasterVolumeState(clamped);
+    for (const [key, pool] of poolsRef.current.entries()) {
+      const entryVol = manifestRef.current[key]?.volume ?? 1;
+      for (const audio of pool) {
+        audio.volume = Math.min(1, entryVol * clamped);
+      }
+    }
+    if (!musicFadeRef.current && currentMusicElRef.current) {
+      const key = currentMusicKeyRef.current;
+      const entryVol = key ? manifestRef.current[key]?.volume ?? 1 : 1;
+      currentMusicElRef.current.volume = Math.min(1, entryVol * clamped);
+    }
+  }, []);
+  const unlockedRef = useRef(false);
+  useEffect(() => {
+    const autoKeys = Object.keys(manifest).filter((k) => manifest[k].autostart);
+    const hasPendingMusic = () => pendingMusicKeyRef.current !== null;
+    const hasAutoStart = autoKeys.length > 0;
+    if (!hasAutoStart && !hasPendingMusic()) return;
+    const unlock = () => {
+      if (unlockedRef.current) return;
+      unlockedRef.current = true;
+      if (!mutedRef.current) {
+        for (const key of autoKeys) {
+          play(key);
+        }
+        const pending = pendingMusicKeyRef.current;
+        if (pending && pending !== currentMusicKeyRef.current) {
+          playMusic(pending);
+        }
+      }
+    };
+    document.addEventListener("click", unlock, { once: true });
+    document.addEventListener("keydown", unlock, { once: true });
+    document.addEventListener("touchstart", unlock, { once: true });
+    return () => {
+      document.removeEventListener("click", unlock);
+      document.removeEventListener("keydown", unlock);
+      document.removeEventListener("touchstart", unlock);
+    };
+  }, [manifest, play, playMusic]);
+  useEffect(() => {
+    return () => {
+      clearMusicFade();
+      for (const pool of poolsRef.current.values()) {
+        for (const audio of pool) {
+          audio.pause();
+          audio.src = "";
+        }
+      }
+      poolsRef.current.clear();
+      if (currentMusicElRef.current) {
+        currentMusicElRef.current.pause();
+        currentMusicElRef.current.src = "";
+        currentMusicElRef.current = null;
+      }
+    };
+  }, [clearMusicFade]);
+  return {
+    play,
+    stop,
+    stopAll,
+    playMusic,
+    stopMusic,
+    muted,
+    setMuted,
+    masterVolume,
+    setMasterVolume
+  };
+}
 var init_useGameAudio = __esm({
   "components/game/shared/hooks/useGameAudio.ts"() {
     "use client";
+    useGameAudio.displayName = "useGameAudio";
   }
 });
 function useGameAudioContextOptional() {
   return useContext(GameAudioContext);
 }
+function GameAudioProvider({
+  manifest,
+  baseUrl = "",
+  children,
+  initialMuted = false
+}) {
+  const eventBus = useEventBus();
+  const { play, stop, stopAll, playMusic, stopMusic, muted, setMuted, masterVolume, setMasterVolume } = useGameAudio({ manifest, baseUrl, initialMuted });
+  useEffect(() => {
+    const unsubPlay = eventBus.on("UI:PLAY_SOUND", (event) => {
+      const key = event.payload?.key;
+      if (key) play(key);
+    });
+    const unsubStop = eventBus.on("UI:STOP_SOUND", (event) => {
+      const key = event.payload?.key;
+      if (key) {
+        stop(key);
+      } else {
+        stopAll();
+      }
+    });
+    const unsubChangeMusic = eventBus.on("UI:CHANGE_MUSIC", (event) => {
+      const key = event.payload?.key;
+      if (key) {
+        playMusic(key);
+      } else {
+        stopMusic();
+      }
+    });
+    const unsubStopMusic = eventBus.on("UI:STOP_MUSIC", () => {
+      stopMusic();
+    });
+    return () => {
+      unsubPlay();
+      unsubStop();
+      unsubChangeMusic();
+      unsubStopMusic();
+    };
+  }, [eventBus, play, stop, stopAll, playMusic, stopMusic]);
+  const value = { muted, setMuted, masterVolume, setMasterVolume, play, playMusic, stopMusic };
+  return /* @__PURE__ */ jsx(GameAudioContext.Provider, { value, children });
+}
 var GameAudioContext;
 var init_GameAudioProvider = __esm({
   "components/game/shared/providers/GameAudioProvider.tsx"() {
@@ -12463,6 +12771,7 @@ var init_GameAudioProvider = __esm({
     init_useGameAudio();
     GameAudioContext = createContext(null);
     GameAudioContext.displayName = "GameAudioContext";
+    GameAudioProvider.displayName = "GameAudioProvider";
   }
 });
 function GameAudioToggle({
@@ -50406,9 +50715,33 @@ var init_ToastSlot = __esm({
     ToastSlot.displayName = "ToastSlot";
   }
 });
-
-// components/core/organisms/component-registry.generated.ts
-var COMPONENT_REGISTRY;
+function lazyThree(name, loader) {
+  const Lazy = React105__default.lazy(
+    () => loader().then((m) => {
+      const Resolved = m[name];
+      if (!Resolved) {
+        throw new Error(
+          `[@almadar/ui] 3D component "${name}" was not found in the three subpath bundle.`
+        );
+      }
+      return { default: Resolved };
+    })
+  );
+  function ThreeWrapper(props) {
+    return React105__default.createElement(
+      ThreeBoundary,
+      { name },
+      React105__default.createElement(
+        React105__default.Suspense,
+        { fallback: null },
+        React105__default.createElement(Lazy, props)
+      )
+    );
+  }
+  ThreeWrapper.displayName = `Lazy(${name})`;
+  return ThreeWrapper;
+}
+var ThreeBoundary, GameBoard3D, GameCanvas3D, GameCanvas3DBattleTemplate, GameCanvas3DCastleTemplate, GameCanvas3DWorldMapTemplate, COMPONENT_REGISTRY;
 var init_component_registry_generated = __esm({
   "components/core/organisms/component-registry.generated.ts"() {
     init_AboutPageTemplate();
@@ -50519,9 +50852,11 @@ var init_component_registry_generated = __esm({
     init_Form();
     init_FormField();
     init_FormSectionHeader();
+    init_GameAudioProvider();
     init_GameAudioToggle();
     init_GameCard();
     init_GameHud();
+    init_GameIcon();
     init_GameMenu();
     init_GameShell();
     init_GameTemplate();
@@ -50706,6 +51041,33 @@ var init_component_registry_generated = __esm({
     init_WizardProgress();
     init_WorldMapBoard();
     init_WorldMapTemplate();
+    ThreeBoundary = class extends React105__default.Component {
+      constructor() {
+        super(...arguments);
+        __publicField(this, "state", { failed: false });
+      }
+      static getDerivedStateFromError() {
+        return { failed: true };
+      }
+      render() {
+        if (this.state.failed) {
+          return React105__default.createElement(
+            "div",
+            {
+              "data-testid": "three-unavailable",
+              style: { padding: 16, fontSize: 13, lineHeight: 1.5, opacity: 0.7 }
+            },
+            `3D pattern "${this.props.name}" requires three.js. Install the optional peers three + @react-three/fiber + @react-three/drei (matching the host React major) to render it.`
+          );
+        }
+        return this.props.children;
+      }
+    };
+    GameBoard3D = lazyThree("GameBoard3D", () => import('@almadar/ui/components/molecules/game/three'));
+    GameCanvas3D = lazyThree("GameCanvas3D", () => import('@almadar/ui/components/molecules/game/three'));
+    GameCanvas3DBattleTemplate = lazyThree("GameCanvas3DBattleTemplate", () => import('@almadar/ui/components/molecules/game/three'));
+    GameCanvas3DCastleTemplate = lazyThree("GameCanvas3DCastleTemplate", () => import('@almadar/ui/components/molecules/game/three'));
+    GameCanvas3DWorldMapTemplate = lazyThree("GameCanvas3DWorldMapTemplate", () => import('@almadar/ui/components/molecules/game/three'));
     COMPONENT_REGISTRY = {
       "AboutPageTemplate": AboutPageTemplate,
       "Accordion": Accordion,
@@ -50821,9 +51183,16 @@ var init_component_registry_generated = __esm({
       "Form": Form,
       "FormField": FormField,
       "FormSectionHeader": FormSectionHeader,
+      "GameAudioProvider": GameAudioProvider,
       "GameAudioToggle": GameAudioToggle,
+      "GameBoard3D": GameBoard3D,
+      "GameCanvas3D": GameCanvas3D,
+      "GameCanvas3DBattleTemplate": GameCanvas3DBattleTemplate,
+      "GameCanvas3DCastleTemplate": GameCanvas3DCastleTemplate,
+      "GameCanvas3DWorldMapTemplate": GameCanvas3DWorldMapTemplate,
       "GameCard": GameCard,
       "GameHud": GameHud,
+      "GameIcon": GameIcon,
       "GameMenu": GameMenu,
       "GameShell": GameShell,
       "GameTemplate": GameTemplate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/ui",
-  "version": "5.76.2",
+  "version": "5.76.5",
   "description": "React UI components, hooks, and providers for Almadar",
   "type": "module",
   "sideEffects": [