vue-micro-router 1.0.1

package/dist/audio.d.ts

@@ -0,0 +1,104 @@
+import { AsyncComponentLoader } from 'vue';
+import { Component } from 'vue';
+import { Ref } from 'vue';
+
+/**
+ * Abstract audio adapter interface — decouples audio playback from a specific library.
+ *
+ * Ship a HowlerAdapter as default. Users can provide a custom adapter
+ * (Web Audio API, Tone.js, etc.) via AudioManagerConfig.adapter.
+ */
+export declare interface AudioAdapter {
+    /** Play a sound from the given source URL */
+    play(src: string, options: {
+        loop?: boolean;
+        volume?: number;
+    }): Promise<void>;
+    /** Stop and unload the current sound */
+    stop(): void;
+    /** Pause playback (preserves position) */
+    pause(): void;
+    /** Resume from paused state */
+    resume(): void;
+    /** Crossfade volume from→to over duration ms */
+    fade(from: number, to: number, duration: number): void;
+    /** Whether audio is currently playing */
+    isPlaying(): boolean;
+    /** Current load state */
+    state(): 'unloaded' | 'loading' | 'loaded';
+    /** Clean up all resources */
+    cleanup(): void;
+}
+
+export declare interface AudioManagerConfig {
+    /** Volume ref (0-100). Defaults to 100. */
+    volumeRef?: Ref<number>;
+    /** Resolve a sound name to a full URL. Defaults to identity (name returned as-is). */
+    urlResolver?: (name: string) => string;
+    /** Custom audio adapter. Defaults to HowlerAdapter (requires howler peer dep). */
+    adapter?: AudioAdapter;
+}
+
+export declare interface AudioManagerState {
+    playSound: (soundSrc: string, loop?: boolean) => Promise<void>;
+    stopSound: () => void;
+    updateBackgroundMusic: (route: string, routes?: Map<string, MicroRoute>) => Promise<void>;
+    handleVisibilityChange: () => void;
+    cleanup: () => void;
+}
+
+export declare class HowlerAdapter implements AudioAdapter {
+    private sound;
+    private howlCtorPromise;
+    /** Lazy-load Howler.js — only imported when first sound is played */
+    private getHowlCtor;
+    play(src: string, options?: {
+        loop?: boolean;
+        volume?: number;
+    }): Promise<void>;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    fade(from: number, to: number, duration: number): void;
+    isPlaying(): boolean;
+    state(): 'unloaded' | 'loading' | 'loaded';
+    cleanup(): void;
+}
+
+declare interface MicroRoute {
+    /** Unique segment name, e.g. "home", "settings" — used in path like "home/settings" */
+    path: string;
+    /** Vue component or async loader (() => import('./MyPage.vue')) */
+    component: AsyncComponentLoader | Component;
+    /** Props passed to the component via useMicroState */
+    attrs?: Record<string, unknown>;
+    /** Background music track name — resolved by audio manager's urlResolver */
+    bgm?: string;
+    /** Preloading strategy: 'eager' (on mount), 'adjacent' (after each nav), false (default) */
+    preload?: 'eager' | 'adjacent' | false;
+    /** Page transition type: 'slide' (default), 'fade', or 'none' to disable */
+    transition?: TransitionType | 'none';
+    /** Custom transition duration in ms. Defaults: slide=500ms, fade=300ms */
+    transitionDuration?: number;
+    /** Guard called before navigating TO this route. Return false to cancel. */
+    beforeEnter?: NavigationGuard;
+    /** Guard called before navigating AWAY from this route. Return false to cancel. */
+    beforeLeave?: NavigationGuard;
+    /** Internal: cache key for transition identity */
+    key?: string;
+    /** Internal: incremented to force full component remount */
+    componentKey?: number;
+}
+
+/**
+ * Guard called before navigation. Return false (or resolve to false) to cancel.
+ * @param to - target path
+ * @param from - current path
+ */
+declare type NavigationGuard = (to: string, from: string) => boolean | Promise<boolean>;
+
+declare type TransitionType = 'fade' | 'slide' | 'scale';
+
+export declare function useAudioManager(config?: AudioManagerConfig): AudioManagerState;
+
+export { }

package/dist/audio.mjs

@@ -0,0 +1,100 @@
+import { ref as v, computed as C, watch as P } from "vue";
+import { d as S } from "./timer-manager.mjs";
+class b {
+  constructor() {
+    this.sound = null, this.howlCtorPromise = null;
+  }
+  /** Lazy-load Howler.js — only imported when first sound is played */
+  async getHowlCtor() {
+    return this.howlCtorPromise || (this.howlCtorPromise = import("howler").then((s) => s.Howl)), this.howlCtorPromise;
+  }
+  async play(s, u = {}) {
+    this.stop();
+    const t = await this.getHowlCtor();
+    this.sound = new t({
+      src: [s],
+      autoplay: !0,
+      loop: u.loop ?? !1,
+      volume: 0
+    }), this.sound.fade(0, u.volume ?? 1, 200);
+  }
+  stop() {
+    try {
+      this.sound && (this.sound.stop(), this.sound.off(), this.sound.unload(), this.sound = null);
+    } catch {
+      this.sound = null;
+    }
+  }
+  pause() {
+    var s;
+    (s = this.sound) != null && s.playing() && this.sound.pause();
+  }
+  resume() {
+    this.sound && this.state() === "loaded" && this.sound.play();
+  }
+  fade(s, u, t) {
+    var a;
+    (a = this.sound) != null && a.playing() && this.sound.fade(s, u, t);
+  }
+  isPlaying() {
+    var s;
+    return ((s = this.sound) == null ? void 0 : s.playing()) ?? !1;
+  }
+  state() {
+    return this.sound ? this.sound.state() : "unloaded";
+  }
+  cleanup() {
+    this.stop();
+  }
+}
+function g(o) {
+  let s = !1, u = "default";
+  const t = (o == null ? void 0 : o.adapter) ?? new b(), a = v("default"), c = (o == null ? void 0 : o.urlResolver) ?? ((e) => e), d = C(() => {
+    var e;
+    return (((e = o == null ? void 0 : o.volumeRef) == null ? void 0 : e.value) ?? 100) / 100;
+  });
+  async function h(e, n = !1) {
+    try {
+      if (t.isPlaying() && a.value === e) return;
+      u = a.value, a.value = e, t.stop(), await S(50), await t.play(c(e), { loop: n, volume: d.value });
+    } catch (l) {
+      console.error("Sound playback failed:", l), t.stop();
+    }
+  }
+  function f() {
+    t.stop();
+  }
+  async function y(e, n) {
+    if (n)
+      try {
+        const l = e.split("/").pop() || "home", r = n.get(l), i = (r == null ? void 0 : r.bgm) || a.value, p = u;
+        p && i && p !== i && await h(i, !0);
+      } catch (l) {
+        console.error("Error updating background music:", l);
+      }
+  }
+  function m() {
+    if (!(typeof document > "u"))
+      try {
+        document.hidden ? t.isPlaying() && (t.pause(), s = !0) : s && t.state() === "loaded" && (t.resume(), s = !1);
+      } catch {
+        t.stop();
+      }
+  }
+  function w() {
+    t.cleanup();
+  }
+  return P(d, (e, n) => {
+    t.isPlaying() && t.fade(n ?? 0, e, 300);
+  }), {
+    playSound: h,
+    stopSound: f,
+    updateBackgroundMusic: y,
+    handleVisibilityChange: m,
+    cleanup: w
+  };
+}
+export {
+  b as HowlerAdapter,
+  g as useAudioManager
+};