@myscheme/voice-navigation-sdk 0.1.0

package/dist/actions.js

@@ -0,0 +1,478 @@
+const ALLOWED_ACTIONS = new Set([
+    "zoom_in",
+    "zoom_out",
+    "scroll_up",
+    "scroll_down",
+    "scroll_left",
+    "scroll_right",
+    "page_up",
+    "page_down",
+    "scroll_top",
+    "scroll_bottom",
+    "go_back",
+    "go_forward",
+    "reload_page",
+    "print_page",
+    "copy_url",
+    "open_menu",
+    "close_menu",
+    "focus_search",
+    "toggle_fullscreen",
+    "exit_fullscreen",
+    "play_media",
+    "pause_media",
+    "mute_media",
+    "unmute_media",
+    "navigate_home",
+    "search_content",
+    "navigate_search",
+    "navigate_faqs",
+    "navigate_help",
+    "navigate_contact",
+    "navigate_about",
+    "navigate_screen_reader",
+    "navigate_accessibility",
+    "navigate_disclaimer",
+    "navigate_terms_conditions",
+    "stop",
+    "unknown",
+]);
+const ZOOM_STEP = 0.1;
+const MIN_ZOOM = 0.5;
+const MAX_ZOOM = 2.0;
+const SCROLL_AMOUNT = 240;
+const notifyNavigationIntent = (context, target) => {
+    const handler = context?.handler;
+    if (handler?.prepareForNavigation) {
+        handler.prepareForNavigation({ target });
+    }
+};
+const ensureZoomBaseline = () => {
+    const root = document.documentElement;
+    if (!root.dataset.navigateZoom) {
+        root.dataset.navigateZoom = "1";
+        root.style.setProperty("--navigate-zoom-scale", "1");
+    }
+};
+export const setZoomScale = (scale) => {
+    ensureZoomBaseline();
+    const clamped = Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, scale));
+    const rounded = parseFloat(clamped.toFixed(2));
+    const root = document.documentElement;
+    root.dataset.navigateZoom = String(rounded);
+    root.style.setProperty("--navigate-zoom-scale", String(rounded));
+    root.style.fontSize = `${clamped * 100}%`;
+    return clamped;
+};
+export const adjustZoom = (delta) => {
+    ensureZoomBaseline();
+    const current = parseFloat(document.documentElement.dataset.navigateZoom || "1");
+    return setZoomScale(current + delta);
+};
+export const formatActionLabel = (action) => {
+    return action.replace(/_/g, " ");
+};
+export const performAgentAction = (action, context = {}) => {
+    if (!action) {
+        return { performed: false, info: {} };
+    }
+    document.documentElement.dataset.navigateRequestedAction = action;
+    let performed = false;
+    const info = {};
+    const onStop = context?.onStop;
+    switch (action) {
+        case "zoom_in": {
+            const newZoom = adjustZoom(ZOOM_STEP);
+            console.log(`Zoomed in to ${newZoom}`);
+            info.newZoom = newZoom;
+            performed = true;
+            break;
+        }
+        case "zoom_out": {
+            const newZoom = adjustZoom(-ZOOM_STEP);
+            console.log(`Zoomed out to ${newZoom}`);
+            info.newZoom = newZoom;
+            performed = true;
+            break;
+        }
+        case "scroll_up": {
+            window.scrollBy({ top: -SCROLL_AMOUNT, behavior: "smooth" });
+            console.log("Scrolled up");
+            info.scrolled = true;
+            info.direction = "up";
+            performed = true;
+            break;
+        }
+        case "scroll_down": {
+            window.scrollBy({ top: SCROLL_AMOUNT, behavior: "smooth" });
+            console.log("Scrolled down");
+            info.scrolled = true;
+            info.direction = "down";
+            performed = true;
+            break;
+        }
+        case "scroll_left": {
+            window.scrollBy({ left: -SCROLL_AMOUNT, behavior: "smooth" });
+            console.log("Scrolled left");
+            info.scrolled = true;
+            info.direction = "left";
+            performed = true;
+            break;
+        }
+        case "scroll_right": {
+            window.scrollBy({ left: SCROLL_AMOUNT, behavior: "smooth" });
+            console.log("Scrolled right");
+            info.scrolled = true;
+            info.direction = "right";
+            performed = true;
+            break;
+        }
+        case "page_up": {
+            window.scrollBy({ top: -window.innerHeight, behavior: "smooth" });
+            console.log("Paged up");
+            info.scrolled = true;
+            info.direction = "page up";
+            performed = true;
+            break;
+        }
+        case "page_down": {
+            window.scrollBy({ top: window.innerHeight, behavior: "smooth" });
+            console.log("Paged down");
+            info.scrolled = true;
+            info.direction = "page down";
+            performed = true;
+            break;
+        }
+        case "scroll_top": {
+            window.scrollTo({ top: 0, behavior: "smooth" });
+            console.log("Scrolled to top");
+            info.scrolled = true;
+            info.direction = "top";
+            performed = true;
+            break;
+        }
+        case "scroll_bottom": {
+            window.scrollTo({
+                top: document.documentElement.scrollHeight,
+                behavior: "smooth",
+            });
+            console.log("Scrolled to bottom");
+            info.scrolled = true;
+            info.direction = "bottom";
+            performed = true;
+            break;
+        }
+        case "go_back": {
+            if (typeof window !== "undefined" && window.history.length > 1) {
+                notifyNavigationIntent(context);
+                window.history.back();
+                console.log("Navigated back");
+                info.navigated = true;
+                performed = true;
+            }
+            break;
+        }
+        case "go_forward": {
+            notifyNavigationIntent(context);
+            window.history.forward();
+            console.log("Navigated forward");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "reload_page": {
+            notifyNavigationIntent(context, window.location.href);
+            window.location.reload();
+            console.log("Page reloaded");
+            info.reloaded = true;
+            performed = true;
+            break;
+        }
+        case "print_page": {
+            window.print();
+            console.log("Print dialog opened");
+            info.printed = true;
+            performed = true;
+            break;
+        }
+        case "copy_url": {
+            if (navigator.clipboard && window.isSecureContext) {
+                navigator.clipboard
+                    .writeText(window.location.href)
+                    .then(() => console.log("Page URL copied to clipboard"))
+                    .catch((error) => {
+                    console.warn("Failed to copy URL via clipboard API", error);
+                });
+                info.copied = true;
+                performed = true;
+            }
+            else {
+                try {
+                    const textarea = document.createElement("textarea");
+                    textarea.value = window.location.href;
+                    textarea.style.position = "fixed";
+                    textarea.style.opacity = "0";
+                    document.body.appendChild(textarea);
+                    textarea.focus();
+                    textarea.select();
+                    const copied = document.execCommand("copy");
+                    document.body.removeChild(textarea);
+                    if (copied) {
+                        console.log("Page URL copied using fallback method");
+                        info.copied = true;
+                        performed = true;
+                    }
+                }
+                catch (error) {
+                    console.warn("Failed to copy URL", error);
+                }
+            }
+            break;
+        }
+        case "open_menu": {
+            const menuButton = document.querySelector('[aria-label*="menu" i], [aria-label*="navigation" i], .menu-button, .hamburger');
+            if (menuButton) {
+                menuButton.click();
+                console.log("Opened menu");
+                info.clicked = true;
+                performed = true;
+            }
+            break;
+        }
+        case "close_menu": {
+            const closeButton = document.querySelector('[aria-label*="close" i], .close-button, .modal-close');
+            if (closeButton) {
+                closeButton.click();
+                console.log("Closed menu");
+                info.clicked = true;
+                performed = true;
+            }
+            break;
+        }
+        case "focus_search": {
+            const searchElement = document.querySelector('input[type="search"], input[name*="search" i], input[aria-label*="search" i], input[placeholder*="search" i], [role="search"] input');
+            if (searchElement instanceof HTMLInputElement) {
+                searchElement.focus({ preventScroll: false });
+                searchElement.select();
+                console.log("Focused on search input");
+                info.focused = true;
+                performed = true;
+            }
+            break;
+        }
+        case "toggle_fullscreen": {
+            const element = document.fullscreenElement;
+            if (element) {
+                document
+                    .exitFullscreen()
+                    .then(() => console.log("Exited fullscreen"))
+                    .catch((error) => console.warn("Failed to exit fullscreen", error));
+                info.fullscreen = false;
+                performed = true;
+            }
+            else if (document.documentElement.requestFullscreen) {
+                document.documentElement
+                    .requestFullscreen()
+                    .then(() => console.log("Entered fullscreen"))
+                    .catch((error) => console.warn("Failed to enter fullscreen", error));
+                info.fullscreen = true;
+                performed = true;
+            }
+            break;
+        }
+        case "exit_fullscreen": {
+            if (document.fullscreenElement) {
+                document
+                    .exitFullscreen()
+                    .then(() => console.log("Exited fullscreen"))
+                    .catch((error) => console.warn("Failed to exit fullscreen", error));
+                info.fullscreen = false;
+                performed = true;
+            }
+            break;
+        }
+        case "play_media": {
+            const media = Array.from(document.querySelectorAll("video, audio")).find((item) => item.paused);
+            if (media) {
+                void media
+                    .play()
+                    .then(() => console.log("Media playback started"))
+                    .catch((error) => console.warn("Failed to play media", error));
+                info.mediaState = "playing";
+                performed = true;
+            }
+            break;
+        }
+        case "pause_media": {
+            const media = Array.from(document.querySelectorAll("video, audio")).find((item) => !item.paused);
+            if (media) {
+                media.pause();
+                console.log("Media playback paused");
+                info.mediaState = "paused";
+                performed = true;
+            }
+            break;
+        }
+        case "mute_media": {
+            const media = Array.from(document.querySelectorAll("video, audio"));
+            if (media.length > 0) {
+                media.forEach((item) => {
+                    item.muted = true;
+                });
+                console.log("Media muted");
+                info.muted = true;
+                performed = true;
+            }
+            break;
+        }
+        case "unmute_media": {
+            const media = Array.from(document.querySelectorAll("video, audio"));
+            if (media.length > 0) {
+                media.forEach((item) => {
+                    item.muted = false;
+                });
+                console.log("Media unmuted");
+                info.muted = false;
+                performed = true;
+            }
+            break;
+        }
+        case "navigate_home": {
+            notifyNavigationIntent(context, "/");
+            window.location.href = "/";
+            console.log("Navigating to home");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "search_content": {
+            console.log("Vector search action delegated to controller");
+            info.searchPending = true;
+            performed = false;
+            break;
+        }
+        case "navigate_search": {
+            notifyNavigationIntent(context, "/search");
+            window.location.href = "/search";
+            console.log("Navigating to search");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_faqs": {
+            notifyNavigationIntent(context, "/faqs");
+            window.location.href = "/faqs";
+            console.log("Navigating to FAQs");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_help": {
+            notifyNavigationIntent(context, "/help");
+            window.location.href = "/help";
+            console.log("Navigating to help");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_contact": {
+            notifyNavigationIntent(context, "/contact");
+            window.location.href = "/contact";
+            console.log("Navigating to contact");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_about": {
+            notifyNavigationIntent(context, "/about");
+            window.location.href = "/about";
+            console.log("Navigating to about");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_screen_reader": {
+            notifyNavigationIntent(context, "/screen-reader-access");
+            window.location.href = "/screen-reader-access";
+            console.log("Navigating to screen reader");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_accessibility": {
+            notifyNavigationIntent(context, "/accessibility");
+            window.location.href = "/accessibility";
+            console.log("Navigating to accessibility");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_disclaimer": {
+            notifyNavigationIntent(context, "/disclaimer");
+            window.location.href = "/disclaimer";
+            console.log("Navigating to disclaimer");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "navigate_terms_conditions": {
+            notifyNavigationIntent(context, "/terms-and-conditions");
+            window.location.href = "/terms-and-conditions";
+            console.log("Navigating to terms and conditions");
+            info.navigated = true;
+            performed = true;
+            break;
+        }
+        case "stop": {
+            console.log("Stop command received");
+            if (onStop) {
+                onStop();
+            }
+            performed = true;
+            break;
+        }
+        default: {
+            console.log(`Unknown action: ${action}`);
+            performed = false;
+            break;
+        }
+    }
+    if (performed) {
+        console.log(`Action "${action}" performed successfully`);
+    }
+    return { performed, info };
+};
+export const extractAgentAction = (result) => {
+    if (!result) {
+        return null;
+    }
+    let raw = "";
+    console.log("Extracting action from result:", result, typeof result);
+    if (typeof result === "string") {
+        raw = result;
+    }
+    else if (result.content && Array.isArray(result.content)) {
+        raw = result.content[0]?.text || "";
+    }
+    else if (result.text) {
+        raw = result.text;
+    }
+    else if (typeof result === "object" && result?.action) {
+        raw = result?.action;
+    }
+    console.log("raw reslt", raw, result);
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed;
+    }
+    catch (error) {
+        console.error("Failed to parse agent action:", error);
+        return { action: raw };
+    }
+};
+export const isAllowedAction = (action) => {
+    return ALLOWED_ACTIONS.has(action);
+};

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_VECTOR_SEARCH_API_PATH = "/api/voice-navigation/vector-search";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,wCAAwC,CAAC"}

package/dist/constants.js

@@ -0,0 +1 @@
+export const DEFAULT_VECTOR_SEARCH_API_PATH = "/api/voice-navigation/vector-search";

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { VoiceNavigationController } from "./navigation-controller.js";
+export { MicrophoneHandler } from "./microphone-handler.js";
+export { AzureSpeechService } from "./services/azure-speech.js";
+export { BedrockService } from "./services/bedrock.js";
+export * from "./types.js";
+export * from "./actions.js";
+export * from "./ui.js";
+import { VoiceNavigationController } from "./navigation-controller.js";
+import type { NavigationConfig } from "./types.js";
+export declare function initNavigationOnMicrophone(config: NavigationConfig): VoiceNavigationController;
+//# 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":"AAMA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA2JnD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,gBAAgB,GACvB,yBAAyB,CA0E3B"}

package/dist/index.js

@@ -0,0 +1,156 @@
+export { VoiceNavigationController } from "./navigation-controller.js";
+export { MicrophoneHandler } from "./microphone-handler.js";
+export { AzureSpeechService } from "./services/azure-speech.js";
+export { BedrockService } from "./services/bedrock.js";
+export * from "./types.js";
+export * from "./actions.js";
+export * from "./ui.js";
+import { VoiceNavigationController } from "./navigation-controller.js";
+const CONFIG_STORAGE_KEY = "__voice_navigation_config";
+const resolveOpenSearchConfig = (config) => {
+    if (!config) {
+        return undefined;
+    }
+    const alias = config.openSearch;
+    const resolved = config.opensearch ?? alias;
+    if (!resolved || typeof resolved !== "object") {
+        return undefined;
+    }
+    return resolved;
+};
+const normalizeNavigationConfig = (config) => ({
+    ...config,
+    opensearch: resolveOpenSearchConfig(config),
+});
+const buildPersistableConfig = (config) => {
+    const normalizedConfig = normalizeNavigationConfig(config);
+    const hasCustomHandlers = Boolean(normalizedConfig.actionHandlers &&
+        Object.keys(normalizedConfig.actionHandlers).length > 0);
+    const persistable = {
+        aws: normalizedConfig.aws ? { ...normalizedConfig.aws } : undefined,
+        azure: normalizedConfig.azure ? { ...normalizedConfig.azure } : undefined,
+        opensearch: normalizedConfig.opensearch
+            ? { ...normalizedConfig.opensearch }
+            : undefined,
+        language: normalizedConfig.language,
+        autoStart: normalizedConfig.autoStart,
+    };
+    if (hasCustomHandlers) {
+        persistable.hasCustomHandlers = true;
+    }
+    return persistable;
+};
+const readPersistedConfig = () => {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    if (typeof sessionStorage === "undefined") {
+        return null;
+    }
+    try {
+        const raw = sessionStorage.getItem(CONFIG_STORAGE_KEY);
+        if (!raw) {
+            return null;
+        }
+        const parsed = JSON.parse(raw);
+        if (parsed.hasCustomHandlers) {
+            console.warn("Voice navigation custom action handlers are not restored automatically. Re-register them on each page load.");
+        }
+        const { hasCustomHandlers: _ignored, ...rest } = parsed;
+        return rest;
+    }
+    catch (error) {
+        console.warn("Failed to read persisted voice navigation config:", error);
+        return null;
+    }
+};
+const describeOpenSearchConfig = (config) => {
+    if (!config) {
+        return "";
+    }
+    const { node, username, password, index, vectorField, size, minScore, numCandidates, sourceFields, ssl, apiPath, } = config;
+    return JSON.stringify({
+        node,
+        username,
+        password,
+        index,
+        vectorField,
+        size,
+        minScore,
+        numCandidates,
+        sourceFields,
+        ssl,
+        apiPath,
+    });
+};
+export function initNavigationOnMicrophone(config) {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+        throw new Error("Voice navigation requires a browser environment");
+    }
+    const globalWindow = window;
+    const normalizedConfig = normalizeNavigationConfig(config);
+    const previousConfigRaw = globalWindow.__voiceNavigationConfig;
+    const previousConfig = previousConfigRaw
+        ? normalizeNavigationConfig(previousConfigRaw)
+        : undefined;
+    globalWindow.__voiceNavigationConfig = normalizedConfig;
+    try {
+        if (typeof sessionStorage !== "undefined") {
+            const persistable = buildPersistableConfig(normalizedConfig);
+            sessionStorage.setItem(CONFIG_STORAGE_KEY, JSON.stringify(persistable));
+        }
+    }
+    catch (error) {
+        console.warn("Failed to persist voice navigation config:", error);
+    }
+    if (globalWindow.__navigateOnMicrophoneInitialized) {
+        const existingController = globalWindow.navigationController;
+        const previousOpenSearchConfig = resolveOpenSearchConfig(previousConfig);
+        const currentOpenSearchConfig = resolveOpenSearchConfig(normalizedConfig);
+        const hadVectorSearch = Boolean(previousOpenSearchConfig);
+        const wantsVectorSearch = Boolean(currentOpenSearchConfig);
+        const existingHasVectorSearch = Boolean(existingController?.vectorSearchService);
+        const vectorConfigChanged = hadVectorSearch &&
+            wantsVectorSearch &&
+            describeOpenSearchConfig(previousOpenSearchConfig) !==
+                describeOpenSearchConfig(currentOpenSearchConfig);
+        if (wantsVectorSearch &&
+            (!hadVectorSearch || vectorConfigChanged || !existingHasVectorSearch)) {
+            try {
+                existingController?.destroy?.();
+            }
+            catch (disposeError) {
+                console.warn("Failed to dispose existing voice navigation controller:", disposeError);
+            }
+            globalWindow.__navigateOnMicrophoneInitialized = false;
+            globalWindow.navigationController = undefined;
+        }
+        else {
+            console.warn("Voice navigation already initialized");
+            return existingController;
+        }
+    }
+    if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+        throw new Error("Microphone access is not supported in this browser");
+    }
+    globalWindow.__navigateOnMicrophoneInitialized = true;
+    const controller = new VoiceNavigationController(normalizedConfig);
+    globalWindow.navigationController = controller;
+    return controller;
+}
+if (typeof window !== "undefined") {
+    const globalWindow = window;
+    const autoConfigRaw = globalWindow.__voiceNavigationConfig || readPersistedConfig();
+    if (autoConfigRaw) {
+        const autoConfig = normalizeNavigationConfig(autoConfigRaw);
+        try {
+            if (!globalWindow.__voiceNavigationConfig) {
+                globalWindow.__voiceNavigationConfig = autoConfig;
+            }
+            initNavigationOnMicrophone(autoConfig);
+        }
+        catch (error) {
+            console.error("Failed to auto-initialize voice navigation:", error);
+        }
+    }
+}