use-ear 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 piro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# use-ear
+
+React hooks for wake word detection using Web Speech API.
+
+## Features
+
+- Wake word detection with customizable keywords
+- Multi-language support with per-word language settings
+- Mobile-friendly with audio session keep-alive
+- TypeScript support
+
+## Installation
+
+```bash
+npm install use-ear
+```
+
+## Usage
+
+### Basic Usage
+
+```tsx
+import { useEar } from "use-ear";
+
+function App() {
+  const { isListening, isSupported, start, stop, transcript } = useEar({
+    wakeWords: ["hello", "hey"],
+    onWakeWord: (word, transcript) => {
+      console.log(`Detected: ${word}`);
+    },
+    language: "en-US",
+  });
+
+  return (
+    <div>
+      <button onClick={isListening ? stop : start}>
+        {isListening ? "Stop" : "Start"}
+      </button>
+      <p>Transcript: {transcript}</p>
+    </div>
+  );
+}
+```
+
+### Multi-language Support
+
+You can specify different languages for each wake word:
+
+```tsx
+useEar({
+  wakeWords: [
+    { word: "hello", language: "en-US" },
+    { word: "hey", language: "en-US" },
+    { word: "ヘイ", language: "ja-JP" },
+    { word: "オーケー", language: "ja-JP" },
+  ],
+  onWakeWord: (word) => {
+    console.log(`Detected: ${word}`);
+  },
+});
+```
+
+The recognition engine rotates through languages automatically.
+
+### Stop Words
+
+You can specify stop words to automatically stop listening:
+
+```tsx
+useEar({
+  wakeWords: ["hello", "hey"],
+  onWakeWord: (word) => {
+    console.log(`Detected: ${word}`);
+  },
+  stopWords: ["stop", "cancel"],
+  onStopWord: (word) => {
+    console.log(`Stopped by: ${word}`);
+  },
+});
+```
+
+### Screen Lock (Prevent Sleep)
+
+Enable `screenLock` to prevent the screen from sleeping during listening:
+
+```tsx
+useEar({
+  wakeWords: ["hello"],
+  onWakeWord: (word) => {
+    console.log(`Detected: ${word}`);
+  },
+  screenLock: true, // Keeps screen awake
+});
+```
+
+This uses the Wake Lock API to prevent the device from dimming or locking the screen. Useful for hands-free applications where you need continuous listening.
+
+## API
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `wakeWords` | `(string \| WakeWord)[]` | required | Wake words to detect |
+| `onWakeWord` | `(word: string, transcript: string) => void` | required | Callback when wake word is detected |
+| `stopWords` | `(string \| WakeWord)[]` | `[]` | Words that stop listening when detected |
+| `onStopWord` | `(word: string, transcript: string) => void` | - | Callback when stop word is detected |
+| `language` | `string` | `"ja-JP"` | Default language for speech recognition |
+| `continuous` | `boolean` | `true` | Keep listening after detection |
+| `caseSensitive` | `boolean` | `false` | Case-sensitive matching |
+| `keepAlive` | `boolean` | `true` | Keep audio session alive (for mobile) |
+| `screenLock` | `boolean` | `false` | Prevent screen from sleeping (Wake Lock API) |
+
+### Return Values
+
+| Value | Type | Description |
+|-------|------|-------------|
+| `isListening` | `boolean` | Currently listening |
+| `isSupported` | `boolean` | Browser supports Web Speech API |
+| `start` | `() => void` | Start listening |
+| `stop` | `() => void` | Stop listening |
+| `error` | `Error \| null` | Error if any |
+| `transcript` | `string` | Last recognized text |
+
+## Browser Support
+
+Web Speech API is supported in:
+- Chrome (Desktop & Android)
+- Safari (Desktop & iOS)
+- Edge
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run demo
+npm run dev
+
+# Build library
+npm run build:lib
+
+# Lint
+npm run lint
+```
+
+## License
+
+MIT

package/dist/hooks/useEar.d.ts

@@ -0,0 +1,46 @@
+import type { UseEarOptions, UseEarReturn } from "../types";
+interface SpeechRecognitionResult {
+    readonly isFinal: boolean;
+    readonly length: number;
+    item(index: number): SpeechRecognitionAlternative;
+    [index: number]: SpeechRecognitionAlternative;
+}
+interface SpeechRecognitionAlternative {
+    readonly transcript: string;
+    readonly confidence: number;
+}
+interface SpeechRecognitionResultList {
+    readonly length: number;
+    item(index: number): SpeechRecognitionResult;
+    [index: number]: SpeechRecognitionResult;
+}
+interface SpeechRecognitionEvent extends Event {
+    readonly results: SpeechRecognitionResultList;
+    readonly resultIndex: number;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    readonly error: string;
+    readonly message: string;
+}
+interface SpeechRecognitionInstance extends EventTarget {
+    continuous: boolean;
+    interimResults: boolean;
+    lang: string;
+    onstart: ((this: SpeechRecognitionInstance, ev: Event) => void) | null;
+    onresult: ((this: SpeechRecognitionInstance, ev: SpeechRecognitionEvent) => void) | null;
+    onerror: ((this: SpeechRecognitionInstance, ev: SpeechRecognitionErrorEvent) => void) | null;
+    onend: ((this: SpeechRecognitionInstance, ev: Event) => void) | null;
+    start(): void;
+    stop(): void;
+    abort(): void;
+}
+type SpeechRecognitionConstructor = new () => SpeechRecognitionInstance;
+declare global {
+    interface Window {
+        SpeechRecognition?: SpeechRecognitionConstructor;
+        webkitSpeechRecognition?: SpeechRecognitionConstructor;
+    }
+}
+export declare function useEar(options: UseEarOptions): UseEarReturn;
+export {};
+//# sourceMappingURL=useEar.d.ts.map

package/dist/hooks/useEar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEar.d.ts","sourceRoot":"","sources":["../../src/hooks/useEar.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAiB,MAAM,UAAU,CAAC;AAE3E,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,4BAA4B,CAAC;IAClD,CAAC,KAAK,EAAE,MAAM,GAAG,4BAA4B,CAAC;CAC/C;AAED,UAAU,4BAA4B;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,UAAU,2BAA2B;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAAC;IAC7C,CAAC,KAAK,EAAE,MAAM,GAAG,uBAAuB,CAAC;CAC1C;AAED,UAAU,sBAAuB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,UAAU,2BAA4B,SAAQ,KAAK;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,UAAU,yBAA0B,SAAQ,WAAW;IACrD,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACvE,QAAQ,EACJ,CAAC,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,sBAAsB,KAAK,IAAI,CAAC,GACvE,IAAI,CAAC;IACT,OAAO,EACH,CAAC,CACC,IAAI,EAAE,yBAAyB,EAC/B,EAAE,EAAE,2BAA2B,KAC5B,IAAI,CAAC,GACV,IAAI,CAAC;IACT,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACrE,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,IAAI,IAAI,CAAC;CACf;AAED,KAAK,4BAA4B,GAAG,UAAU,yBAAyB,CAAC;AAExE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,iBAAiB,CAAC,EAAE,4BAA4B,CAAC;QACjD,uBAAuB,CAAC,EAAE,4BAA4B,CAAC;KACxD;CACF;AAuFD,wBAAgB,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAsQ3D"}

package/dist/hooks/useEar.js

@@ -0,0 +1,273 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+const getSpeechRecognition = () => {
+    if (typeof window === "undefined")
+        return null;
+    return window.SpeechRecognition || window.webkitSpeechRecognition || null;
+};
+const createKeepAlive = () => {
+    if (typeof window === "undefined")
+        return null;
+    try {
+        const context = new AudioContext();
+        const oscillator = context.createOscillator();
+        const gain = context.createGain();
+        // ほぼ無音（完全に0だと最適化で停止される可能性がある）
+        gain.gain.value = 0.001;
+        oscillator.connect(gain);
+        gain.connect(context.destination);
+        oscillator.start();
+        return { context, oscillator, gain };
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const stopKeepAlive = (keepAlive) => {
+    try {
+        keepAlive.oscillator.stop();
+        keepAlive.oscillator.disconnect();
+        keepAlive.gain.disconnect();
+        keepAlive.context.close();
+    }
+    catch (_a) {
+        // 既に停止している場合は無視
+    }
+};
+const normalizeWakeWords = (wakeWords, defaultLanguage) => {
+    return wakeWords.map((w) => typeof w === "string" ? { word: w, language: defaultLanguage } : w);
+};
+const getUniqueLanguages = (wakeWords) => {
+    return [...new Set(wakeWords.map((w) => w.language))];
+};
+// Wake Lock API
+const requestWakeLock = async () => {
+    if (typeof navigator === "undefined" || !("wakeLock" in navigator)) {
+        return null;
+    }
+    try {
+        return await navigator.wakeLock.request("screen");
+    }
+    catch (_a) {
+        // Wake Lock APIがサポートされていない、または権限がない場合
+        return null;
+    }
+};
+const releaseWakeLock = async (wakeLock) => {
+    if (wakeLock) {
+        try {
+            await wakeLock.release();
+        }
+        catch (_a) {
+            // 既に解放されている場合は無視
+        }
+    }
+};
+export function useEar(options) {
+    const { wakeWords, onWakeWord, stopWords = [], onStopWord, continuous = true, language = "ja-JP", caseSensitive = false, keepAlive = true, screenLock = false, } = options;
+    const [isListening, setIsListening] = useState(false);
+    const [hasMounted, setHasMounted] = useState(false);
+    const [error, setError] = useState(null);
+    const [transcript, setTranscript] = useState("");
+    const recognitionRef = useRef(null);
+    const keepAliveRef = useRef(null);
+    const wakeLockRef = useRef(null);
+    const onWakeWordRef = useRef(onWakeWord);
+    const onStopWordRef = useRef(onStopWord);
+    const languageIndexRef = useRef(0);
+    const shouldContinueRef = useRef(false);
+    // ワードを正規化して言語リストを取得
+    const normalizedWakeWords = normalizeWakeWords(wakeWords, language);
+    const normalizedStopWords = normalizeWakeWords(stopWords, language);
+    const allWords = [...normalizedWakeWords, ...normalizedStopWords];
+    const languages = getUniqueLanguages(allWords);
+    const normalizedWakeWordsRef = useRef(normalizedWakeWords);
+    const normalizedStopWordsRef = useRef(normalizedStopWords);
+    const languagesRef = useRef(languages);
+    // 参照を更新
+    useEffect(() => {
+        onWakeWordRef.current = onWakeWord;
+        onStopWordRef.current = onStopWord;
+        normalizedWakeWordsRef.current = normalizedWakeWords;
+        normalizedStopWordsRef.current = normalizedStopWords;
+        languagesRef.current = languages;
+    }, [
+        onWakeWord,
+        onStopWord,
+        normalizedWakeWords,
+        normalizedStopWords,
+        languages,
+    ]);
+    // マウント後にブラウザサポートをチェック（SSRでのhydration mismatchを防ぐ）
+    useEffect(() => {
+        setHasMounted(true);
+    }, []);
+    // hasMountedがtrueになってから実際のサポート状況を返す
+    const isSupported = hasMounted && getSpeechRecognition() !== null;
+    const stopRef = useRef(() => { });
+    const checkStopWord = useCallback((text) => {
+        var _a;
+        const normalizedText = caseSensitive ? text : text.toLowerCase();
+        for (const stopWord of normalizedStopWordsRef.current) {
+            const normalizedWord = caseSensitive
+                ? stopWord.word
+                : stopWord.word.toLowerCase();
+            if (normalizedText.includes(normalizedWord)) {
+                (_a = onStopWordRef.current) === null || _a === void 0 ? void 0 : _a.call(onStopWordRef, stopWord.word, text);
+                stopRef.current();
+                return true;
+            }
+        }
+        return false;
+    }, [caseSensitive]);
+    const checkWakeWord = useCallback((text) => {
+        const normalizedText = caseSensitive ? text : text.toLowerCase();
+        // まずストップワードをチェック
+        if (checkStopWord(text)) {
+            return false;
+        }
+        for (const wakeWord of normalizedWakeWordsRef.current) {
+            const normalizedWord = caseSensitive
+                ? wakeWord.word
+                : wakeWord.word.toLowerCase();
+            if (normalizedText.includes(normalizedWord)) {
+                onWakeWordRef.current(wakeWord.word, text);
+                return true;
+            }
+        }
+        return false;
+    }, [caseSensitive, checkStopWord]);
+    const startWithLanguage = useCallback((lang) => {
+        const SpeechRecognitionClass = getSpeechRecognition();
+        if (!SpeechRecognitionClass) {
+            setError(new Error("SpeechRecognition is not supported in this browser"));
+            return;
+        }
+        // 既存のインスタンスを停止
+        if (recognitionRef.current) {
+            recognitionRef.current.stop();
+        }
+        const recognition = new SpeechRecognitionClass();
+        recognition.continuous = continuous;
+        recognition.interimResults = true;
+        recognition.lang = lang;
+        recognition.onstart = () => {
+            setIsListening(true);
+            setError(null);
+        };
+        recognition.onresult = (event) => {
+            const results = Array.from(event.results);
+            const latestResult = results[results.length - 1];
+            if (latestResult) {
+                const text = latestResult[0].transcript;
+                setTranscript(text);
+                checkWakeWord(text);
+            }
+        };
+        recognition.onerror = (event) => {
+            setError(new Error(`Speech recognition error: ${event.error}`));
+            setIsListening(false);
+        };
+        recognition.onend = () => {
+            // continuous モードの場合は次の言語で再開
+            if (shouldContinueRef.current && continuous) {
+                // 次の言語にローテーション
+                languageIndexRef.current =
+                    (languageIndexRef.current + 1) % languagesRef.current.length;
+                const nextLang = languagesRef.current[languageIndexRef.current];
+                // 少し遅延を入れて再開（ブラウザの制限回避）
+                setTimeout(() => {
+                    if (shouldContinueRef.current) {
+                        startWithLanguage(nextLang);
+                    }
+                }, 100);
+            }
+            else {
+                setIsListening(false);
+            }
+        };
+        recognitionRef.current = recognition;
+        try {
+            recognition.start();
+        }
+        catch (e) {
+            setError(e instanceof Error ? e : new Error("Failed to start recognition"));
+        }
+    }, [continuous, checkWakeWord]);
+    const start = useCallback(async () => {
+        shouldContinueRef.current = true;
+        languageIndexRef.current = 0;
+        // keepAliveが有効な場合、オーディオセッションを維持
+        if (keepAlive && !keepAliveRef.current) {
+            keepAliveRef.current = createKeepAlive();
+        }
+        // screenLockが有効な場合、画面の自動ロックを防ぐ
+        if (screenLock && !wakeLockRef.current) {
+            wakeLockRef.current = await requestWakeLock();
+        }
+        const initialLang = languagesRef.current[0] || language;
+        startWithLanguage(initialLang);
+    }, [keepAlive, screenLock, language, startWithLanguage]);
+    const stop = useCallback(async () => {
+        shouldContinueRef.current = false;
+        if (recognitionRef.current) {
+            recognitionRef.current.stop();
+            recognitionRef.current = null;
+        }
+        if (keepAliveRef.current) {
+            stopKeepAlive(keepAliveRef.current);
+            keepAliveRef.current = null;
+        }
+        if (wakeLockRef.current) {
+            await releaseWakeLock(wakeLockRef.current);
+            wakeLockRef.current = null;
+        }
+        setIsListening(false);
+    }, []);
+    // stopRefを更新してcheckStopWordから呼び出せるようにする
+    useEffect(() => {
+        stopRef.current = stop;
+    }, [stop]);
+    // Wake Lockはページが非表示になると自動解放されるため、再取得する
+    useEffect(() => {
+        if (!screenLock)
+            return;
+        const handleVisibilityChange = async () => {
+            if (document.visibilityState === "visible" &&
+                shouldContinueRef.current &&
+                !wakeLockRef.current) {
+                wakeLockRef.current = await requestWakeLock();
+            }
+        };
+        document.addEventListener("visibilitychange", handleVisibilityChange);
+        return () => {
+            document.removeEventListener("visibilitychange", handleVisibilityChange);
+        };
+    }, [screenLock]);
+    // クリーンアップ
+    useEffect(() => {
+        return () => {
+            shouldContinueRef.current = false;
+            if (recognitionRef.current) {
+                recognitionRef.current.stop();
+                recognitionRef.current = null;
+            }
+            if (keepAliveRef.current) {
+                stopKeepAlive(keepAliveRef.current);
+                keepAliveRef.current = null;
+            }
+            if (wakeLockRef.current) {
+                releaseWakeLock(wakeLockRef.current);
+                wakeLockRef.current = null;
+            }
+        };
+    }, []);
+    return {
+        isListening,
+        isSupported,
+        start,
+        stop,
+        error,
+        transcript,
+    };
+}

package/dist/hooks/usePwa.d.ts

@@ -0,0 +1,26 @@
+export type UserChoice = {
+    outcome: "accepted" | "dismissed";
+    platform: string;
+};
+interface BeforeInstallPromptEvent extends Event {
+    readonly platforms: string[];
+    readonly userChoice: Promise<UserChoice>;
+    prompt(): Promise<void>;
+}
+declare global {
+    interface WindowEventMap {
+        beforeinstallprompt: BeforeInstallPromptEvent;
+    }
+    interface Navigator {
+        standalone?: boolean;
+    }
+}
+export type PwaData = {
+    canInstall: boolean;
+    install: () => Promise<UserChoice | undefined>;
+    isInstalled: boolean;
+    isSupported: boolean;
+};
+export declare function usePwa(): PwaData;
+export {};
+//# sourceMappingURL=usePwa.d.ts.map

package/dist/hooks/usePwa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePwa.d.ts","sourceRoot":"","sources":["../../src/hooks/usePwa.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,UAAU,GAAG,WAAW,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,UAAU,wBAAyB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IACzC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,cAAc;QACtB,mBAAmB,EAAE,wBAAwB,CAAC;KAC/C;IAED,UAAU,SAAS;QACjB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF;AAYD,MAAM,MAAM,OAAO,GAAG;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;IAC/C,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,MAAM,IAAI,OAAO,CAsFhC"}

package/dist/hooks/usePwa.js

@@ -0,0 +1,78 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+// Capture event at module load time (before React hydration)
+let capturedEvent = null;
+if (typeof window !== "undefined") {
+    window.addEventListener("beforeinstallprompt", (event) => {
+        event.preventDefault();
+        capturedEvent = event;
+    });
+}
+export function usePwa() {
+    const promptEvent = useRef(capturedEvent);
+    const [canInstall, setCanInstall] = useState(false);
+    const [isInstalled, setIsInstalled] = useState(false);
+    const [isSupported, setIsSupported] = useState(false);
+    const install = useCallback(async () => {
+        if (!promptEvent.current) {
+            return undefined;
+        }
+        await promptEvent.current.prompt();
+        const choice = await promptEvent.current.userChoice;
+        if (choice.outcome === "accepted") {
+            setCanInstall(false);
+            promptEvent.current = null;
+            capturedEvent = null;
+        }
+        return choice;
+    }, []);
+    // Check for captured event and listen for future events
+    useEffect(() => {
+        // Use captured event if available
+        if (capturedEvent) {
+            promptEvent.current = capturedEvent;
+            setCanInstall(true);
+        }
+        const handleBeforeInstallPrompt = (event) => {
+            event.preventDefault();
+            promptEvent.current = event;
+            capturedEvent = event;
+            setCanInstall(true);
+        };
+        window.addEventListener("beforeinstallprompt", handleBeforeInstallPrompt);
+        return () => {
+            window.removeEventListener("beforeinstallprompt", handleBeforeInstallPrompt);
+        };
+    }, []);
+    // Detect if running as installed PWA
+    useEffect(() => {
+        // Android Trusted Web App
+        if (document.referrer.includes("android-app://")) {
+            setIsInstalled(true);
+            return;
+        }
+        // Chrome PWA (supporting fullscreen, standalone, minimal-ui)
+        const displayModes = ["fullscreen", "standalone", "minimal-ui"];
+        const isDisplayModePwa = displayModes.some((mode) => window.matchMedia(`(display-mode: ${mode})`).matches);
+        if (isDisplayModePwa) {
+            setIsInstalled(true);
+            return;
+        }
+        // iOS PWA Standalone
+        if (navigator.standalone) {
+            setIsInstalled(true);
+        }
+    }, []);
+    // Detect PWA support
+    useEffect(() => {
+        if ("BeforeInstallPromptEvent" in window) {
+            setIsSupported(true);
+        }
+    }, []);
+    return {
+        canInstall,
+        install,
+        isInstalled,
+        isSupported,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { useEar } from "./hooks/useEar";
+export type { UseEarOptions, UseEarReturn, WakeWord, WakeWordInput, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,YAAY,EACV,aAAa,EACb,YAAY,EACZ,QAAQ,EACR,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { useEar } from "./hooks/useEar";

package/dist/types/index.d.ts

@@ -0,0 +1,42 @@
+export interface WakeWord {
+    /** ウェイクワード */
+    word: string;
+    /** このワード用の言語設定 */
+    language: string;
+}
+export type WakeWordInput = string | WakeWord;
+export interface UseEarOptions {
+    /** 検出するウェイクアップワードの配列 */
+    wakeWords: WakeWordInput[];
+    /** ウェイクワード検出時に呼ばれるコールバック */
+    onWakeWord: (word: string, transcript: string) => void;
+    /** リッスンを停止するワードの配列 */
+    stopWords?: WakeWordInput[];
+    /** ストップワード検出時に呼ばれるコールバック */
+    onStopWord?: (word: string, transcript: string) => void;
+    /** 継続的にリッスンするか (default: true) */
+    continuous?: boolean;
+    /** デフォルトの言語設定 (default: 'ja-JP') */
+    language?: string;
+    /** 大文字小文字を区別しない (default: false) */
+    caseSensitive?: boolean;
+    /** モバイルでバックグラウンド時もオーディオセッションを維持する (default: true) */
+    keepAlive?: boolean;
+    /** 画面の自動ロックを防ぐ (default: false) */
+    screenLock?: boolean;
+}
+export interface UseEarReturn {
+    /** 現在リッスン中かどうか */
+    isListening: boolean;
+    /** ブラウザがWeb Speech APIをサポートしているか */
+    isSupported: boolean;
+    /** リッスンを開始 */
+    start: () => void;
+    /** リッスンを停止 */
+    stop: () => void;
+    /** エラー情報 */
+    error: Error | null;
+    /** 最後に認識されたテキスト */
+    transcript: string;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,cAAc;IACd,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B,wBAAwB;IACxB,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,4BAA4B;IAC5B,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,sBAAsB;IACtB,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAC5B,4BAA4B;IAC5B,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,kCAAkC;IAClC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qDAAqD;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,mCAAmC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,kBAAkB;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc;IACd,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,cAAc;IACd,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,YAAY;IACZ,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "use-ear",
+  "version": "0.1.0",
+  "description": "React hooks for wake word detection using Web Speech API",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "react",
+    "hooks",
+    "speech-recognition",
+    "wake-word",
+    "voice",
+    "web-speech-api"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/piro0919/use-ear.git"
+  },
+  "homepage": "https://github.com/piro0919/use-ear#readme",
+  "bugs": {
+    "url": "https://github.com/piro0919/use-ear/issues"
+  },
+  "author": "piro0919",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "build:lib": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build:lib",
+    "start": "next start",
+    "lint": "biome check",
+    "format": "biome format --write"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.2.0",
+    "@serwist/turbopack": "^9.4.2",
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "babel-plugin-react-compiler": "1.0.0",
+    "esbuild-wasm": "^0.27.2",
+    "next": "16.1.1",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "react-ios-pwa-prompt": "^2.0.6",
+    "serwist": "^9.4.2",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}