@foisit/react-wrapper 2.0.1 → 2.1.2

package/index.mjs

@@ -0,0 +1,1084 @@
+import { jsx as u } from "react/jsx-runtime";
+import { createContext as A, useState as x, useEffect as w, useContext as I } from "react";
+const E = {};
+function Y() {
+  return /* @__PURE__ */ u("div", { className: E.container, children: /* @__PURE__ */ u("h1", { children: "Welcome to ReactWrapper!" }) });
+}
+class L {
+  constructor() {
+    this.endpoint = "https://foisit-ninja.netlify.app/.netlify/functions/intent";
+  }
+  /**
+   * Determine the best matching command by calling the internalized proxy
+   */
+  async determineIntent(e, t, i) {
+    try {
+      const s = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          userInput: e,
+          context: i,
+          commands: t.map((c) => ({
+            id: c.id,
+            command: c.command,
+            description: c.description,
+            keywords: c.keywords,
+            parameters: c.parameters
+          }))
+        })
+      });
+      if (!s.ok)
+        throw new Error("Proxy API request failed");
+      return await s.json();
+    } catch (s) {
+      return console.error("Foisit AI Error:", s), { type: "unknown" };
+    }
+  }
+}
+class M {
+  constructor(e = !0) {
+    this.commands = /* @__PURE__ */ new Map(), this.pendingConfirmation = null, this.conversationContext = null, this.enableSmartIntent = !0, this.enableSmartIntent = e, this.aiService = new L();
+  }
+  /**
+   * Add a new command (supports simple string or rich object)
+   */
+  addCommand(e, t) {
+    let i;
+    if (typeof e == "string") {
+      if (!t)
+        throw new Error("Action is required when passing a command string.");
+      i = {
+        command: e,
+        action: t,
+        id: `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+        // Auto-gen ID
+      };
+    } else
+      i = e, i.id || (i.id = `cmd_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`);
+    const s = i.command.toLowerCase();
+    this.commands.set(s, i);
+  }
+  /** Remove an existing command by trigger phrase */
+  removeCommand(e) {
+    const t = e.toLowerCase();
+    this.commands.has(t) && this.commands.delete(t);
+  }
+  /** Execute a command by matching input (string or parameter object) */
+  async executeCommand(e) {
+    var c;
+    if (typeof e == "object" && this.conversationContext) {
+      const o = Array.from(this.commands.values()).find(
+        (a) => {
+          var n;
+          return a.id === ((n = this.conversationContext) == null ? void 0 : n.commandId);
+        }
+      );
+      if (o) {
+        const a = { ...this.conversationContext.params, ...e };
+        return this.conversationContext = null, this.runAction(o, a);
+      }
+    }
+    const t = (typeof e == "string" ? e : "").toLowerCase().trim();
+    if (this.pendingConfirmation)
+      if (t === "yes" || t === "y" || t === "confirm") {
+        const o = this.pendingConfirmation;
+        return this.pendingConfirmation = null, this.runAction(o);
+      } else return t === "no" || t === "n" || t === "cancel" ? (this.pendingConfirmation = null, { type: "success", message: "Action cancelled." }) : {
+        type: "ambiguous",
+        message: `Please confirm: Are you sure you want to ${this.pendingConfirmation.description || this.pendingConfirmation.command}?`,
+        options: [
+          { label: "Yes", value: "yes" },
+          { label: "No", value: "no" }
+        ]
+      };
+    if (!this.conversationContext) {
+      const o = this.commands.get(t);
+      if (o) {
+        if (!o.parameters || o.parameters.length === 0)
+          return o.critical ? (this.pendingConfirmation = o, {
+            type: "ambiguous",
+            message: `Are you sure you want to ${o.description || o.command}?`,
+            options: [
+              { label: "Yes", value: "yes" },
+              { label: "No", value: "no" }
+            ]
+          }) : this.runAction(o);
+        this.conversationContext = {
+          commandId: o.id || "",
+          params: {}
+        };
+        const a = await Promise.all(
+          o.parameters.map(async (n) => {
+            let h = n.options;
+            if (n.getOptions)
+              try {
+                h = await n.getOptions();
+              } catch (m) {
+                console.error(`Error fetching options for ${n.name}`, m);
+              }
+            return {
+              name: n.name,
+              label: n.name.charAt(0).toUpperCase() + n.name.slice(1),
+              value: "",
+              required: n.required,
+              type: n.type || "string",
+              options: h
+            };
+          })
+        );
+        return {
+          type: "form",
+          message: o.description || `Please fill in the details for ${o.command}:`,
+          fields: a
+        };
+      }
+    }
+    const i = Array.from(this.commands.values());
+    if (this.enableSmartIntent) {
+      const o = await this.aiService.determineIntent(
+        t,
+        i,
+        this.conversationContext
+      );
+      if (o.type === "match" && o.match) {
+        const a = i.find((n) => n.id === o.match);
+        if (a) {
+          const n = {
+            ...((c = this.conversationContext) == null ? void 0 : c.params) || {},
+            ...o.params || {}
+          };
+          if (o.incomplete) {
+            if (this.conversationContext = {
+              commandId: a.id,
+              params: n
+            }, a.parameters && a.parameters.length > 0) {
+              const h = await Promise.all(
+                a.parameters.map(async (m) => {
+                  let d = m.options;
+                  if (m.getOptions)
+                    try {
+                      d = await m.getOptions();
+                    } catch (g) {
+                      console.error(`Error fetching options for ${m.name}`, g);
+                    }
+                  return {
+                    name: m.name,
+                    label: m.name.charAt(0).toUpperCase() + m.name.slice(1),
+                    value: n[m.name] || "",
+                    required: m.required,
+                    type: m.type || "string",
+                    options: d
+                  };
+                })
+              );
+              return {
+                type: "form",
+                message: o.message || `Please fill in the details for ${a.command}:`,
+                fields: h
+              };
+            }
+            return {
+              type: "ambiguous",
+              message: o.message || `Need more info for ${a.command}...`
+            };
+          }
+          return this.conversationContext = null, a.critical ? (this.pendingConfirmation = {
+            ...a,
+            action: () => a.action(n)
+          }, {
+            type: "ambiguous",
+            message: `Are you sure you want to ${a.description || a.command}?`,
+            options: [
+              { label: "Yes", value: "yes" },
+              { label: "No", value: "no" }
+            ]
+          }) : this.runAction(a, n);
+        }
+      } else if (o.type === "ambiguous" && o.options)
+        return {
+          type: "ambiguous",
+          message: "Did you mean...",
+          options: o.options.map((a) => ({
+            label: a.label,
+            value: a.label
+          }))
+        };
+    }
+    return {
+      type: "ambiguous",
+      message: "I'm not sure what you mean. Here is what I can do:",
+      options: i.map((o) => ({
+        label: o.command,
+        value: o.command
+      }))
+    };
+  }
+  /** Run a command action and handle rich responses */
+  async runAction(e, t) {
+    try {
+      const i = await e.action(t);
+      return typeof i == "string" ? { type: "success", message: i } : i && i.type ? i : {
+        type: "success",
+        message: `Executed: ${e.command}`
+      };
+    } catch (i) {
+      return {
+        type: "error",
+        message: i.message || "An error occurred during execution."
+      };
+    }
+  }
+  /** List all registered commands */
+  getCommands() {
+    return Array.from(this.commands.keys());
+  }
+}
+class k {
+  constructor() {
+    this.synth = window.speechSynthesis;
+  }
+  speak(e, t) {
+    if (!this.synth) {
+      console.error("SpeechSynthesis API is not supported in this browser.");
+      return;
+    }
+    const i = new SpeechSynthesisUtterance(e);
+    t && (i.pitch = t.pitch || 1, i.rate = t.rate || 1, i.volume = t.volume || 1), i.onend = () => {
+      console.log("Speech finished.");
+    }, i.onerror = (s) => {
+      console.error("Error during speech synthesis:", s.error);
+    }, this.synth.speak(i);
+  }
+  stopSpeaking() {
+    this.synth && this.synth.cancel();
+  }
+}
+class P {
+  constructor() {
+    this.fallbackMessage = "Sorry, I didn’t understand that.";
+  }
+  setFallbackMessage(e) {
+    this.fallbackMessage = e;
+  }
+  handleFallback(e) {
+    console.log(this.fallbackMessage), new k().speak(this.fallbackMessage);
+  }
+}
+class T {
+  constructor(e = "en-US") {
+    this.isListening = !1, this.isStoppedSpeechRecog = !1, this.restartAllowed = !0;
+  }
+  /** Start listening for speech input */
+  startListening(e) {
+    console.warn("VoiceProcessor: Voice interaction is currently DISABLED.");
+  }
+  /** Stop listening for speech input */
+  stopListening() {
+    if (console.log("VoiceProcessor: Stopping listening..."), this.isStoppedSpeechRecog = !0, this.restartAllowed = !1, !this.isListening) {
+      console.warn("VoiceProcessor: Already stopped. Skipping stop...");
+      return;
+    }
+    try {
+      this.recognition.stop(), this.isListening = !1, console.log("VoiceProcessor: Listening stopped.");
+    } catch (e) {
+      console.error("VoiceProcessor: Failed to stop SpeechRecognition:", e);
+    }
+  }
+  /** Handle recognized speech results */
+  handleResult(e, t) {
+  }
+  /** Handle session end */
+  handleEnd() {
+    console.log("VoiceProcessor: Session ended."), this.isListening = !1, this.restartAllowed && !this.isStoppedSpeechRecog && (console.log(
+      "VoiceProcessor: Restarting session due to unexpected stop..."
+    ), setTimeout(() => this.startListening(() => {
+    }), 560));
+  }
+  /** Handle errors during speech recognition */
+  handleError(e) {
+    console.error("VoiceProcessor: Error occurred:", e.error), e.error === "no-speech" ? console.log("VoiceProcessor: No speech detected.") : e.error === "audio-capture" && console.log("VoiceProcessor: Microphone not detected."), this.isListening = !1;
+  }
+}
+class B {
+  constructor() {
+    this.lastTap = 0;
+  }
+  /**
+   * Sets up double-click and double-tap listeners
+   * @param onDoubleClickOrTap Callback to execute when a double-click or double-tap is detected
+   */
+  setupDoubleTapListener(e) {
+    document.addEventListener("dblclick", () => {
+      e();
+    }), document.addEventListener("touchend", (t) => {
+      const i = (/* @__PURE__ */ new Date()).getTime(), s = i - this.lastTap;
+      s < 300 && s > 0 && e(), this.lastTap = i;
+    });
+  }
+}
+function D() {
+  if (document.querySelector("#assistant-styles")) {
+    console.log("Styles already injected");
+    return;
+  }
+  const e = document.createElement("style");
+  e.id = "assistant-styles", e.innerHTML = `
+    /* Rounded shape with gradient animation */
+    .gradient-indicator {
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      width: 60px;
+      height: 60px;
+      border-radius: 50%;
+      background: linear-gradient(135deg, #ff6ec4, #7873f5, #5e8cff, #6ed0f6);
+      box-shadow: 0 0 15px rgba(0, 0, 0, 0.2);
+      animation: amoeba 5s infinite ease-in-out;
+      z-index: 9999; /* Ensure it's above all other elements */
+    }
+
+    /* Amoeba effect for the borders */
+    @keyframes amoeba {
+      0% {
+        border-radius: 50%;
+      }
+      25% {
+        border-radius: 40% 60% 60% 40%;
+      }
+      50% {
+        border-radius: 60% 40% 40% 60%;
+      }
+      75% {
+        border-radius: 40% 60% 60% 40%;
+      }
+      100% {
+        border-radius: 50%;
+      }
+    }
+  `, document.head.appendChild(e), console.log("Gradient styles injected");
+}
+function R() {
+  if (document.querySelector("#gradient-indicator"))
+    return;
+  const r = document.createElement("div");
+  r.id = "gradient-indicator", D(), r.classList.add("gradient-indicator"), document.body.appendChild(r), console.log("Gradient indicator added to the DOM");
+}
+function H() {
+  const r = document.querySelector("#gradient-indicator");
+  r && (r.remove(), console.log("Gradient indicator removed from the DOM"));
+}
+class N {
+  constructor() {
+    this.state = "idle", this.subscribers = [];
+  }
+  getState() {
+    return this.state;
+  }
+  setState(e) {
+    this.state = e, this.notifySubscribers(), console.log("State updated:", e), e === "listening" ? R() : H();
+  }
+  // eslint-disable-next-line no-unused-vars
+  subscribe(e) {
+    this.subscribers.push(e);
+  }
+  notifySubscribers() {
+    this.subscribers.forEach((e) => e(this.state));
+  }
+}
+const l = class l {
+  constructor(e) {
+    this.isOpen = !1, this.submitCallback = null, this.closeCallback = null, this.chatContainer = null, this.config = {}, e && (this.config = e), this.injectStyles(), this.injectOverlay(), this.injectFloatingButton(), this.setupEventListeners(), this.chatContainer = document.getElementById(
+      "foisit-chat-history"
+    );
+  }
+  /**
+   * Cleanup everything from the DOM
+   */
+  destroy() {
+    const e = document.getElementById(l.OVERLAY_ID);
+    e && e.remove();
+    const t = document.getElementById(l.STYLES_ID);
+    t && t.remove();
+    const i = document.getElementById("foisit-floating-btn");
+    i && i.remove(), this.isOpen = !1, this.chatContainer = null, this.submitCallback = null, this.closeCallback = null;
+  }
+  /**
+   * Register callbacks for the overlay (used by floating button)
+   */
+  registerCallbacks(e, t) {
+    this.submitCallback = e, this.closeCallback = t || null;
+  }
+  /**
+   * Show the overlay and focus input
+   */
+  show(e, t) {
+    const i = document.getElementById(l.OVERLAY_ID), s = document.getElementById(
+      l.INPUT_ID
+    );
+    this.chatContainer = document.getElementById(
+      "foisit-chat-history"
+    ), i && s && (this.submitCallback = e, this.closeCallback = t || null, i.style.display = "flex", setTimeout(() => {
+      i.classList.add("visible"), s.focus(), s.focus(), s.value = "", this.chatContainer && (this.chatContainer.innerHTML = "");
+    }, 10), this.isOpen = !0);
+  }
+  /**
+   * Hide the overlay
+   */
+  hide() {
+    const e = document.getElementById(l.OVERLAY_ID);
+    e && (e.classList.remove("visible"), setTimeout(() => {
+      e.style.display = "none";
+    }, 300), this.isOpen = !1, this.closeCallback && this.closeCallback());
+  }
+  /**
+   * Toggle the overlay
+   */
+  toggle(e, t) {
+    this.isOpen ? this.hide() : this.show(e, t);
+  }
+  /**
+   * Add a message bubble to the chat
+   */
+  addMessage(e, t = "system") {
+    if (!this.chatContainer) return;
+    const i = document.createElement("div");
+    i.className = `foisit-bubble ${t}`, i.textContent = e, this.chatContainer.appendChild(i), this.scrollToBottom();
+  }
+  /**
+   * Add clickable options to the chat
+   */
+  addOptions(e) {
+    if (!this.chatContainer) return;
+    const t = document.createElement("div");
+    t.className = "foisit-options-container", e.forEach((i) => {
+      const s = document.createElement("button");
+      s.className = "foisit-option-chip", s.textContent = i.label, s.onclick = () => {
+        this.addMessage(i.label, "user"), this.submitCallback && this.submitCallback(i.value);
+      }, t.appendChild(s);
+    }), this.chatContainer.appendChild(t), this.scrollToBottom();
+  }
+  /**
+   * Inject the floating trigger button
+   */
+  injectFloatingButton() {
+    var s, c, o, a;
+    if (((s = this.config.floatingButton) == null ? void 0 : s.visible) === !1) return;
+    const e = document.getElementById("foisit-floating-btn");
+    e && e.remove();
+    const t = document.createElement("div");
+    t.id = "foisit-floating-btn", t.className = "foisit-floating-btn", t.title = ((c = this.config.floatingButton) == null ? void 0 : c.tooltip) || "Open Foisit Assistant";
+    const i = (o = this.config.floatingButton) == null ? void 0 : o.position;
+    i && (t.style.bottom = i.bottom, t.style.right = i.right), (a = this.config.floatingButton) != null && a.customHtml ? t.innerHTML = this.config.floatingButton.customHtml : t.innerHTML = `
+        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+          <path d="M12 2C6.48 2 2 6.48 2 12C2 17.52 6.48 22 12 22C17.52 22 22 17.52 22 12C22 6.48 17.52 2 12 2ZM12 4C16.42 4 20 7.58 20 12C20 16.42 16.42 20 12 20C7.58 20 4 16.42 4 12C4 7.58 7.58 4 12 4Z" fill="white" fill-opacity="0.8"/>
+          <path d="M12 6C8.69 6 6 8.69 6 12C6 15.31 8.69 18 12 18C15.31 18 18 15.31 18 12C18 8.69 15.31 6 12 6ZM12 16C9.79 16 8 14.21 8 12C8 9.79 9.79 8 12 8C14.21 8 16 9.79 16 12C16 14.21 14.21 16 12 16Z" fill="white"/>
+        </svg>
+      `, t.onclick = () => {
+      this.submitCallback && this.toggle(this.submitCallback, this.closeCallback || void 0);
+    }, document.body.appendChild(t);
+  }
+  /**
+   * Add a dynamic form to the chat
+   */
+  addForm(e, t, i) {
+    if (!this.chatContainer) return;
+    const s = document.createElement("div");
+    s.className = "foisit-form-card";
+    const c = document.createElement("div");
+    c.className = "foisit-form-message", c.textContent = e, s.appendChild(c);
+    const o = {};
+    t.forEach((n) => {
+      var g, C;
+      const h = document.createElement("div");
+      h.className = "foisit-field-group";
+      const m = document.createElement("label");
+      m.textContent = n.label, h.appendChild(m);
+      let d;
+      if ((n.type === "select" || n.options) && ((g = n.options) != null && g.length) && n.options.length > 0) {
+        d = document.createElement("select"), d.className = "foisit-field-input";
+        const p = document.createElement("option");
+        p.value = "", p.textContent = `Select ${n.label}`, p.disabled = !0, p.selected = !n.value, d.appendChild(p), (C = n.options) == null || C.forEach((y) => {
+          const f = document.createElement("option");
+          f.value = y.value, f.textContent = y.label, n.value === y.value && (f.selected = !0), d.appendChild(f);
+        });
+      } else
+        d = document.createElement("input"), d.className = "foisit-field-input", d.placeholder = n.label, d.value = n.value || "", n.type === "date" ? d.type = "date" : n.type === "number" ? d.type = "number" : d.type = "text";
+      o[n.name] = d, h.appendChild(d), s.appendChild(h);
+    });
+    const a = document.createElement("button");
+    a.className = "foisit-form-submit", a.textContent = "Submit", a.onclick = () => {
+      const n = {};
+      Object.keys(o).forEach((h) => {
+        n[h] = o[h].value;
+      }), a.disabled = !0, a.textContent = "Submitted", s.style.opacity = "0.7", s.style.pointerEvents = "none", i(n);
+    }, s.appendChild(a), this.chatContainer.appendChild(s), this.scrollToBottom();
+  }
+  /**
+   * Show loading indicator
+   */
+  showLoading() {
+    if (!this.chatContainer || document.getElementById("foisit-loading-bubble")) return;
+    const e = document.createElement("div");
+    e.id = "foisit-loading-bubble", e.className = "foisit-bubble system loading", e.innerHTML = "<span>.</span><span>.</span><span>.</span>", this.chatContainer.appendChild(e), this.scrollToBottom();
+  }
+  /**
+   * Hide loading indicator
+   */
+  hideLoading() {
+    const e = document.getElementById("foisit-loading-bubble");
+    e && e.remove();
+  }
+  scrollToBottom() {
+    this.chatContainer && (this.chatContainer.scrollTop = this.chatContainer.scrollHeight);
+  }
+  injectStyles() {
+    if (document.getElementById(l.STYLES_ID)) return;
+    const e = document.createElement("style");
+    e.id = l.STYLES_ID, e.innerHTML = `
+      #${l.OVERLAY_ID} {
+        position: fixed;
+        top: 24px;
+        right: 24px;
+        width: 320px;
+        z-index: 99999;
+        display: none;
+        flex-direction: column;
+        opacity: 0;
+        transition: opacity 0.3s ease-in-out, transform 0.3s ease-in-out;
+        transform: translateY(-10px);
+      }
+
+      #${l.OVERLAY_ID}.visible {
+        opacity: 1;
+        transform: translateY(0);
+      }
+
+      .foisit-content {
+        width: 100%;
+        padding: 0;
+        border-radius: 16px;
+        overflow: hidden;
+        /* Stronger Frosted Look (User Provided) */
+        background: linear-gradient(
+          135deg,
+          rgba(255, 255, 255, 0.25),
+          rgba(255, 255, 255, 0.05)
+        );
+        backdrop-filter: blur(20px);
+        -webkit-backdrop-filter: blur(20px);
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.25);
+        border: 1px solid rgba(255, 255, 255, 0.4);
+        display: flex;
+        flex-direction: column;
+      }
+
+      #${l.INPUT_ID} {
+        width: 100%;
+        background: transparent;
+        border: none;
+        font-size: 16px;
+        color: #333;
+        padding: 18px 20px 12px 20px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        outline: none;
+        text-align: left;
+        resize: none;
+        min-height: 48px;
+        max-height: 200px;
+        overflow-y: auto;
+      }
+
+      #${l.INPUT_ID}::placeholder {
+        color: rgba(60, 60, 67, 0.7);
+        font-weight: 500;
+      }
+      
+      @media (prefers-color-scheme: dark) {
+        .foisit-content {
+           background: linear-gradient(
+              135deg,
+              rgba(40, 40, 40, 0.65),
+              rgba(40, 40, 40, 0.25)
+           );
+           border: 1px solid rgba(255, 255, 255, 0.1);
+        }
+        #${l.INPUT_ID} {
+          color: white;
+        }
+        #${l.INPUT_ID}::placeholder {
+          color: rgba(235, 235, 245, 0.6);
+        }
+        .foisit-watermark {
+          color: rgba(255, 255, 255, 0.5);
+        }
+      }
+
+.foisit-watermark {
+  align-self: flex-end;
+  margin: 0 12px 10px auto;
+  padding: 4px 8px;
+  border-radius: 8px;
+
+  font-size: 9px;
+  font-weight: 600;
+  letter-spacing: 0.8px;
+  text-transform: capitalize;
+
+  background: rgba(0, 0, 0, 0.35);
+  backdrop-filter: blur(6px);
+  -webkit-backdrop-filter: blur(6px);
+
+  color: rgba(255, 255, 255, 0.85);
+  pointer-events: none;
+}
+
+
+      /* Chat UI Styles */
+      #foisit-chat-history {
+        flex: 1;
+        overflow-y: auto;
+        padding: 16px;
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+        max-height: 400px;
+      }
+
+      .foisit-bubble {
+        max-width: 85%;
+        padding: 8px 12px;
+        border-radius: 12px;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+        font-size: 14px;
+        line-height: 1.4;
+      }
+
+      .foisit-bubble.user {
+        align-self: flex-end;
+        background: rgba(0, 0, 0, 0.05); /* Subtle dark for user */
+        color: #333;
+        border-bottom-right-radius: 4px;
+      }
+
+      .foisit-bubble.system {
+        align-self: flex-start;
+        background: rgba(255, 255, 255, 0.4); /* Glassy white */
+        color: #333;
+        border-bottom-left-radius: 4px;
+      }
+
+      .foisit-options-container {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-left: 4px;
+      }
+
+      .foisit-option-chip {
+        padding: 6px 12px;
+        background: rgba(255, 255, 255, 0.5);
+        border: 1px solid rgba(0, 0, 0, 0.1);
+        border-radius: 20px;
+        font-size: 13px;
+        color: #333;
+        cursor: pointer;
+        transition: all 0.2s;
+      }
+
+      .foisit-option-chip:hover {
+        background: rgba(255, 255, 255, 0.8);
+        transform: translateY(-1px);
+        box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+      }
+
+      @media (prefers-color-scheme: dark) {
+        .foisit-bubble.user {
+          background: rgba(255, 255, 255, 0.1);
+          color: white;
+        }
+        .foisit-bubble.system {
+          background: rgba(255, 255, 255, 0.05);
+          color: rgba(255, 255, 255, 0.9);
+        }
+        .foisit-option-chip {
+          background: rgba(255, 255, 255, 0.1);
+          border-color: rgba(255, 255, 255, 0.2);
+          color: white;
+        }
+        .foisit-option-chip:hover {
+          background: rgba(255, 255, 255, 0.2);
+        }
+       /* Loading State */
+      .foisit-loading-dots {
+        display: inline-flex;
+        gap: 4px;
+        align-items: center;
+        padding: 4px 8px;
+        background: rgba(255, 255, 255, 0.4);
+        border-radius: 12px;
+        margin-left: 12px;
+        align-self: flex-start;
+      }
+      .foisit-dot {
+        width: 6px;
+        height: 6px;
+        background: #666;
+        border-radius: 50%;
+        animation: foisit-bounce 1.4s infinite ease-in-out both;
+      }
+      .foisit-dot:nth-child(1) { animation-delay: -0.32s; }
+      .foisit-dot:nth-child(2) { animation-delay: -0.16s; }
+      
+      @keyframes foisit-bounce {
+        0%, 80%, 100% { transform: scale(0); }
+        40% { transform: scale(1); }
+      }
+
+      /* Floating Trigger Button - Glassmorphism Style */
+      .foisit-floating-btn {
+        position: fixed;
+        bottom: 20px;
+        right: 20px;
+        width: 52px;
+        height: 52px;
+        /* Frosted Glass Effect */
+        background: linear-gradient(
+          135deg,
+          rgba(255, 255, 255, 0.25),
+          rgba(255, 255, 255, 0.08)
+        );
+        backdrop-filter: blur(16px);
+        -webkit-backdrop-filter: blur(16px);
+        border-radius: 50%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        cursor: pointer;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2);
+        border: 1px solid rgba(255, 255, 255, 0.35);
+        z-index: 9998;
+        transition: transform 0.2s ease, box-shadow 0.2s ease;
+      }
+
+      .foisit-floating-btn:hover {
+        transform: scale(1.08);
+        box-shadow: 0 12px 40px rgba(0, 0, 0, 0.3);
+      }
+
+      /* Dark mode for floating button */
+      @media (prefers-color-scheme: dark) {
+        .foisit-floating-btn {
+          background: linear-gradient(
+            135deg,
+            rgba(60, 60, 60, 0.6),
+            rgba(40, 40, 40, 0.35)
+          );
+          border-color: rgba(255, 255, 255, 0.15);
+        }
+      }
+      
+      .foisit-floating-btn img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+        border-radius: 50%;
+      }
+      
+      /* Dark mode support for inputs */
+      @media (prefers-color-scheme: dark) {
+        .foisit-field-input {
+           background: rgba(40, 40, 40, 0.6);
+           color: white;
+           border-color: rgba(255, 255, 255, 0.1);
+        }
+      }
+        .foisit-watermark {
+           color: rgba(255, 255, 255, 0.3);
+        }
+      }
+
+      /* Loading Animation */
+      .foisit-bubble.loading span {
+        animation: foisit-dots 1.4s infinite ease-in-out both;
+        font-size: 20px;
+        line-height: 10px;
+        margin: 0 1px;
+      }
+      
+      .foisit-bubble.loading span:nth-child(1) { animation-delay: -0.32s; }
+      .foisit-bubble.loading span:nth-child(2) { animation-delay: -0.16s; }
+      
+      @keyframes foisit-dots {
+        0%, 80%, 100% { transform: scale(0); opacity: 0.5; }
+        40% { transform: scale(1); opacity: 1; }
+      }
+
+      /* Form Styles */
+      .foisit-form-card {
+        align-self: flex-start;
+        background: rgba(255, 255, 255, 0.4);
+        padding: 16px;
+        border-radius: 12px;
+        width: 100%;
+        box-sizing: border-box;
+        border: 1px solid rgba(255, 255, 255, 0.2);
+        display: flex;
+        flex-direction: column;
+        gap: 12px;
+      }
+
+      .foisit-form-message {
+        font-family: -apple-system, sans-serif;
+        font-size: 14px;
+        color: #333;
+        margin-bottom: 4px;
+        font-weight: 500;
+      }
+
+      .foisit-field-group {
+        display: flex;
+        flex-direction: column;
+        gap: 4px;
+      }
+
+      .foisit-field-group label {
+        font-size: 11px;
+        font-weight: 600;
+        text-transform: uppercase;
+        color: rgba(0, 0, 0, 0.5);
+      }
+
+      .foisit-field-input {
+        background: rgba(255, 255, 255, 0.6);
+        border: 1px solid rgba(0, 0, 0, 0.1);
+        border-radius: 8px;
+        padding: 8px 12px;
+        font-size: 14px;
+        color: #333;
+        outline: none;
+      }
+
+      .foisit-field-input:focus {
+        border-color: rgba(0, 0, 0, 0.3);
+      }
+
+      .foisit-form-submit {
+        background: #000;
+        color: #fff;
+        border: none;
+        border-radius: 8px;
+        padding: 10px;
+        font-size: 14px;
+        font-weight: 500;
+        cursor: pointer;
+        transition: opacity 0.2s;
+        margin-top: 4px;
+      }
+
+      .foisit-form-submit:hover {
+        opacity: 0.8;
+      }
+
+      @media (prefers-color-scheme: dark) {
+        .foisit-form-card {
+          background: rgba(255, 255, 255, 0.05);
+          color: white;
+        }
+        .foisit-form-message {
+          color: white;
+        }
+        .foisit-field-group label {
+          color: rgba(255, 255, 255, 0.5);
+        }
+        .foisit-field-input {
+          background: rgba(0, 0, 0, 0.2);
+          border-color: rgba(255, 255, 255, 0.1);
+          color: white;
+        }
+        .foisit-form-submit {
+          background: #fff;
+          color: #000;
+        }
+      }
+
+    `, document.head.appendChild(e);
+  }
+  injectOverlay() {
+    if (document.getElementById(l.OVERLAY_ID)) return;
+    const e = this.config.inputPlaceholder || "How can I help you?", t = document.createElement("div");
+    t.id = l.OVERLAY_ID, t.innerHTML = `
+      <div class="foisit-content">
+        <div id="foisit-chat-history"></div>
+        <textarea id="${l.INPUT_ID}" placeholder="${e}" autocomplete="off" rows="1"></textarea>
+        <div class="foisit-watermark">Foisit</div>
+      </div>
+    `, document.body.appendChild(t);
+  }
+  setupEventListeners() {
+    const e = document.getElementById(l.OVERLAY_ID), t = document.getElementById(
+      l.INPUT_ID
+    );
+    !e || !t || (t.addEventListener("input", () => {
+      t.style.height = "auto", t.style.height = Math.min(t.scrollHeight, 200) + "px";
+    }), e.addEventListener("click", (i) => {
+      i.target === e && this.hide();
+    }), t.addEventListener("keydown", (i) => {
+      if (i.key === "Enter" && !i.shiftKey) {
+        i.preventDefault();
+        const s = t.value.trim();
+        s && this.submitCallback && (this.submitCallback(s), t.value = "", t.style.height = "auto");
+      }
+      i.key === "Escape" && this.hide();
+    }));
+  }
+};
+l.OVERLAY_ID = "foisit-assistant-overlay", l.INPUT_ID = "foisit-assistant-input", l.STYLES_ID = "foisit-assistant-styles";
+let v = l;
+class $ {
+  constructor(e) {
+    this.config = e, this.isActivated = !1, this.lastProcessedInput = "", this.processingLock = !1, this.defaultIntroMessage = "How can I help you?", this.commandHandler = new M(
+      this.config.enableSmartIntent !== !1
+    ), this.fallbackHandler = new P(), this.voiceProcessor = new T(), this.textToSpeech = new k(), this.stateManager = new N(), this.gestureHandler = new B(), this.overlayManager = new v({
+      floatingButton: this.config.floatingButton,
+      inputPlaceholder: this.config.inputPlaceholder
+    }), this.config.commands.forEach((t) => this.commandHandler.addCommand(t)), this.config.fallbackResponse && this.fallbackHandler.setFallbackMessage(this.config.fallbackResponse), this.gestureHandler.setupDoubleTapListener(() => this.toggle()), this.overlayManager.registerCallbacks(
+      async (t) => {
+        this.overlayManager.addMessage(t, "user"), await this.handleCommand(t);
+      },
+      () => console.log("AssistantService: Overlay closed.")
+    );
+  }
+  /** Start listening for activation and commands */
+  startListening() {
+    console.log("AssistantService: Starting listening..."), this.voiceProcessor.startListening(async (e) => {
+      var s, c;
+      if (this.processingLock) return;
+      const t = e.toLowerCase().trim();
+      if (!t || t.length < 3 || t === this.lastProcessedInput) {
+        console.log("AssistantService: Ignoring irrelevant input.");
+        return;
+      }
+      if (this.lastProcessedInput = t, !this.isActivated) {
+        await this.processActivation(t);
+        return;
+      }
+      t === ((s = this.config.fallbackResponse) == null ? void 0 : s.toLowerCase()) || t === ((c = this.config.introMessage) == null ? void 0 : c.toLowerCase()) || t === this.defaultIntroMessage.toLowerCase() ? console.log("AssistantService: Ignoring fallback or intro message.") : await this.handleCommand(t), this.processingLock = !0, setTimeout(() => this.processingLock = !1, 1e3);
+    });
+  }
+  /** Stop listening */
+  stopListening() {
+    console.log("AssistantService: Stopping listening..."), this.voiceProcessor.stopListening(), this.isActivated = !1;
+  }
+  /** Process activation command */
+  async processActivation(e) {
+    var i;
+    const t = (i = this.config.activationCommand) == null ? void 0 : i.toLowerCase();
+    t && (e === t ? (console.log("AssistantService: Activation matched."), this.isActivated = !0, this.textToSpeech.speak(
+      this.config.introMessage || this.defaultIntroMessage
+    )) : console.log("AssistantService: Activation command not recognized."));
+  }
+  /** Handle recognized commands */
+  async handleCommand(e) {
+    this.overlayManager.showLoading();
+    const t = await this.commandHandler.executeCommand(e);
+    this.overlayManager.hideLoading(), t.message && this.overlayManager.addMessage(t.message, "system"), t.type === "form" && t.fields ? this.overlayManager.addForm(
+      t.message,
+      t.fields,
+      async (i) => {
+        this.overlayManager.showLoading();
+        const s = await this.commandHandler.executeCommand(i);
+        this.overlayManager.hideLoading(), this.processResponse(s);
+      }
+    ) : t.type === "ambiguous" && t.options ? this.overlayManager.addOptions(t.options) : t.type === "error" && this.fallbackHandler.handleFallback(e);
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.voiceProcessor.stopListening(), this.overlayManager.destroy();
+  }
+  /** Unified response processing */
+  processResponse(e) {
+    e.message && this.overlayManager.addMessage(e.message, "system"), e.type === "form" && e.fields ? this.overlayManager.addForm(
+      e.message,
+      e.fields,
+      async (t) => {
+        this.overlayManager.showLoading();
+        const i = await this.commandHandler.executeCommand(t);
+        this.overlayManager.hideLoading(), this.processResponse(i);
+      }
+    ) : e.type === "ambiguous" && e.options && this.overlayManager.addOptions(e.options);
+  }
+  /** Add a command dynamically (supports string or rich object) */
+  addCommand(e, t) {
+    console.log(typeof e == "string" ? `AssistantService: Adding command "${e}".` : `AssistantService: Adding rich command "${e.command}".`), this.commandHandler.addCommand(e, t);
+  }
+  /** Remove a command dynamically */
+  removeCommand(e) {
+    console.log(`AssistantService: Removing command "${e}".`), this.commandHandler.removeCommand(e);
+  }
+  /** Get all registered commands */
+  getCommands() {
+    return this.commandHandler.getCommands();
+  }
+  /** Toggle the assistant overlay */
+  toggle(e, t) {
+    console.log("AssistantService: Toggling overlay..."), this.overlayManager.toggle(
+      async (i) => {
+        this.overlayManager.addMessage(i, "user"), e && e(i), await this.handleCommand(i);
+      },
+      () => {
+        console.log("AssistantService: Overlay closed."), t && t();
+      }
+    );
+  }
+}
+const S = A(null);
+let b = null;
+const z = ({ config: r, children: e }) => {
+  const [t, i] = x(null), [s, c] = x(!1);
+  return w(() => {
+    b ? console.warn("Multiple AssistantProvider instances detected. Reusing global AssistantService.") : (console.log("Initializing global AssistantService..."), b = new $(r));
+    const o = b;
+    return i(o), o.startListening(), c(!0), () => {
+      var a;
+      console.log("Cleaning up AssistantService..."), (a = o.destroy) == null || a.call(o), b = null;
+    };
+  }, [r]), !s || !t ? /* @__PURE__ */ u("div", { children: "Loading Assistant..." }) : /* @__PURE__ */ u(S.Provider, { value: t, children: e });
+}, F = () => {
+  const r = I(S);
+  if (console.log("assistant", r), !r)
+    throw new Error("useAssistant must be used within an AssistantProvider");
+  return r;
+}, U = ({
+  label: r = "Activate Assistant",
+  onActivate: e
+}) => {
+  const t = F();
+  return /* @__PURE__ */ u("button", { onClick: () => {
+    e && e(), t.reactivate();
+  }, className: "assistant-activator", children: r });
+}, j = (r) => {
+  const [e, t] = x(r.getState());
+  return w(() => {
+    const i = (s) => {
+      t(s);
+    };
+    return r.subscribe(i), () => {
+      r.subscribe(() => {
+      });
+    };
+  }, [r]), e;
+};
+export {
+  U as AssistantActivator,
+  S as AssistantContext,
+  z as AssistantProvider,
+  $ as AssistantService,
+  Y as ReactWrapper,
+  F as useAssistant,
+  j as useAssistantState
+};