@feedvalue/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1207 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/event-emitter.ts
+var TypedEventEmitter = class {
+  constructor() {
+    // Using a Map with proper typing - the inner Function type is acceptable here
+    // because we handle type safety at the public API level (on/off/emit methods)
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribe to an event
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   */
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+  }
+  /**
+   * Subscribe to an event for a single emission.
+   * The handler will be automatically removed after the first call.
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   */
+  once(event, handler) {
+    const wrappedHandler = ((...args) => {
+      this.off(event, wrappedHandler);
+      handler(...args);
+    });
+    this.on(event, wrappedHandler);
+  }
+  /**
+   * Unsubscribe from an event
+   *
+   * @param event - Event name
+   * @param handler - Optional handler to remove (removes all if not provided)
+   */
+  off(event, handler) {
+    if (!handler) {
+      this.listeners.delete(event);
+      return;
+    }
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit an event to all subscribers
+   *
+   * @param event - Event name
+   * @param args - Arguments to pass to handlers
+   */
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`[FeedValue] Error in ${event} handler:`, error);
+        }
+      }
+    }
+  }
+  /**
+   * Remove all event listeners
+   */
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/api-client.ts
+var DEFAULT_API_BASE_URL = "https://api.feedvalue.com";
+var TOKEN_EXPIRY_BUFFER_SECONDS = 30;
+var CONFIG_CACHE_TTL_MS = 5 * 60 * 1e3;
+var ApiClient = class {
+  constructor(baseUrl = DEFAULT_API_BASE_URL, debug = false) {
+    __publicField(this, "baseUrl");
+    __publicField(this, "debug");
+    // Request deduplication
+    __publicField(this, "pendingRequests", /* @__PURE__ */ new Map());
+    // Config cache
+    __publicField(this, "configCache", /* @__PURE__ */ new Map());
+    // Anti-abuse tokens
+    __publicField(this, "submissionToken", null);
+    __publicField(this, "tokenExpiresAt", null);
+    __publicField(this, "fingerprint", null);
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.debug = debug;
+  }
+  /**
+   * Validate widget ID to prevent path injection attacks
+   * @throws Error if widget ID is invalid
+   */
+  validateWidgetId(widgetId) {
+    if (!widgetId || typeof widgetId !== "string") {
+      throw new Error("Widget ID is required");
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(widgetId)) {
+      throw new Error("Invalid widget ID format: only alphanumeric characters, underscores, and hyphens are allowed");
+    }
+    if (widgetId.length > 64) {
+      throw new Error("Widget ID exceeds maximum length of 64 characters");
+    }
+  }
+  /**
+   * Set client fingerprint for anti-abuse protection
+   */
+  setFingerprint(fingerprint) {
+    this.fingerprint = fingerprint;
+  }
+  /**
+   * Get client fingerprint
+   */
+  getFingerprint() {
+    return this.fingerprint;
+  }
+  /**
+   * Check if submission token is valid
+   */
+  hasValidToken() {
+    if (!this.submissionToken || !this.tokenExpiresAt) {
+      return false;
+    }
+    return Date.now() / 1e3 < this.tokenExpiresAt - TOKEN_EXPIRY_BUFFER_SECONDS;
+  }
+  /**
+   * Fetch widget configuration
+   * Uses caching and request deduplication
+   */
+  async fetchConfig(widgetId) {
+    this.validateWidgetId(widgetId);
+    const cacheKey = `config:${widgetId}`;
+    const cached = this.configCache.get(cacheKey);
+    if (cached && Date.now() < cached.expiresAt) {
+      this.log("Config cache hit", { widgetId });
+      return cached.data;
+    }
+    const pendingKey = `fetchConfig:${widgetId}`;
+    const pending = this.pendingRequests.get(pendingKey);
+    if (pending) {
+      this.log("Deduplicating config request", { widgetId });
+      return pending;
+    }
+    const request = this.doFetchConfig(widgetId);
+    this.pendingRequests.set(pendingKey, request);
+    try {
+      const result = await request;
+      return result;
+    } finally {
+      this.pendingRequests.delete(pendingKey);
+    }
+  }
+  /**
+   * Actually fetch config from API
+   */
+  async doFetchConfig(widgetId) {
+    const url = `${this.baseUrl}/api/v1/widgets/${widgetId}/config`;
+    const headers = {};
+    if (this.fingerprint) {
+      headers["X-Client-Fingerprint"] = this.fingerprint;
+    }
+    this.log("Fetching config", { widgetId, url });
+    const response = await fetch(url, {
+      method: "GET",
+      headers
+    });
+    if (!response.ok) {
+      const error = await this.parseError(response);
+      throw new Error(error);
+    }
+    const data = await response.json();
+    if (data.submission_token) {
+      this.submissionToken = data.submission_token;
+      this.tokenExpiresAt = data.token_expires_at ?? null;
+      this.log("Submission token stored", {
+        expiresAt: this.tokenExpiresAt ? new Date(this.tokenExpiresAt * 1e3).toISOString() : "unknown"
+      });
+    }
+    const cacheKey = `config:${widgetId}`;
+    this.configCache.set(cacheKey, {
+      data,
+      expiresAt: Date.now() + CONFIG_CACHE_TTL_MS
+    });
+    this.log("Config fetched", { widgetId });
+    return data;
+  }
+  /**
+   * Submit feedback with optional user data
+   */
+  async submitFeedback(widgetId, feedback, userData) {
+    this.validateWidgetId(widgetId);
+    const url = `${this.baseUrl}/api/v1/widgets/${widgetId}/feedback`;
+    if (!this.hasValidToken()) {
+      this.log("Token expired, refreshing...");
+      await this.fetchConfig(widgetId);
+    }
+    if (!this.submissionToken) {
+      throw new Error("No submission token available");
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Submission-Token": this.submissionToken
+    };
+    if (this.fingerprint) {
+      headers["X-Client-Fingerprint"] = this.fingerprint;
+    }
+    this.log("Submitting feedback", { widgetId });
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        message: feedback.message,
+        metadata: feedback.metadata,
+        ...feedback.customFieldValues && {
+          customFieldValues: feedback.customFieldValues
+        },
+        ...userData && Object.keys(userData).length > 0 && {
+          user: userData
+        }
+      })
+    });
+    if (response.status === 429) {
+      const resetAt = response.headers.get("X-RateLimit-Reset");
+      const retryAfter = resetAt ? Math.ceil(parseInt(resetAt, 10) - Date.now() / 1e3) : 60;
+      throw new Error(`Rate limited. Try again in ${retryAfter} seconds.`);
+    }
+    if (response.status === 403) {
+      const errorData = await response.json().catch(() => ({ detail: "Access denied" }));
+      if (errorData.detail?.code && errorData.detail?.message) {
+        throw new Error(errorData.detail.message);
+      }
+      const errorMessage = typeof errorData.detail === "string" ? errorData.detail : "";
+      if (errorMessage.includes("token") || errorMessage.includes("expired")) {
+        this.log("Token rejected, refreshing...");
+        this.submissionToken = null;
+        await this.fetchConfig(widgetId);
+        if (this.submissionToken) {
+          headers["X-Submission-Token"] = this.submissionToken;
+          const retryResponse = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+              message: feedback.message,
+              metadata: feedback.metadata,
+              ...feedback.customFieldValues && {
+                customFieldValues: feedback.customFieldValues
+              },
+              ...userData && Object.keys(userData).length > 0 && {
+                user: userData
+              }
+            })
+          });
+          if (retryResponse.ok) {
+            return retryResponse.json();
+          }
+        }
+      }
+      throw new Error(errorMessage || "Access denied");
+    }
+    if (!response.ok) {
+      const error = await this.parseError(response);
+      throw new Error(error);
+    }
+    const data = await response.json();
+    if (data.blocked) {
+      throw new Error(data.message || "Unable to submit feedback");
+    }
+    this.log("Feedback submitted", { feedbackId: data.feedback_id });
+    return data;
+  }
+  /**
+   * Parse error from response
+   */
+  async parseError(response) {
+    try {
+      const data = await response.json();
+      return data.detail || data.message || data.error || `HTTP ${response.status}`;
+    } catch {
+      return `HTTP ${response.status}: ${response.statusText}`;
+    }
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.configCache.clear();
+    this.submissionToken = null;
+    this.tokenExpiresAt = null;
+    this.log("Cache cleared");
+  }
+  /**
+   * Debug logging
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[FeedValue API] ${message}`, data ?? "");
+    }
+  }
+};
+
+// src/fingerprint.ts
+var FINGERPRINT_STORAGE_KEY = "fv_fingerprint";
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateFingerprint() {
+  if (typeof window === "undefined" || typeof sessionStorage === "undefined") {
+    return generateUUID();
+  }
+  const stored = sessionStorage.getItem(FINGERPRINT_STORAGE_KEY);
+  if (stored) {
+    return stored;
+  }
+  const fingerprint = generateUUID();
+  try {
+    sessionStorage.setItem(FINGERPRINT_STORAGE_KEY, fingerprint);
+  } catch {
+  }
+  return fingerprint;
+}
+function clearFingerprint() {
+  if (typeof sessionStorage !== "undefined") {
+    try {
+      sessionStorage.removeItem(FINGERPRINT_STORAGE_KEY);
+    } catch {
+    }
+  }
+}
+
+// src/feedvalue.ts
+var SUCCESS_AUTO_CLOSE_DELAY_MS = 3e3;
+var VALID_SENTIMENTS = ["angry", "disappointed", "satisfied", "excited"];
+var MAX_MESSAGE_LENGTH = 1e4;
+var MAX_METADATA_VALUE_LENGTH = 1e3;
+var DEFAULT_CONFIG = {
+  theme: "auto",
+  autoShow: true,
+  debug: false,
+  locale: "en"
+};
+var instances = /* @__PURE__ */ new Map();
+var FeedValue = class _FeedValue {
+  /**
+   * Create a new FeedValue instance
+   * Use FeedValue.init() for public API
+   */
+  constructor(options) {
+    __publicField(this, "widgetId");
+    __publicField(this, "apiClient");
+    __publicField(this, "emitter");
+    __publicField(this, "headless");
+    __publicField(this, "config");
+    __publicField(this, "widgetConfig", null);
+    // State
+    __publicField(this, "state", {
+      isReady: false,
+      isOpen: false,
+      isVisible: true,
+      error: null,
+      isSubmitting: false
+    });
+    // State subscribers (for React useSyncExternalStore)
+    __publicField(this, "stateSubscribers", /* @__PURE__ */ new Set());
+    __publicField(this, "stateSnapshot");
+    // User data (stored for future API submissions)
+    __publicField(this, "_userData", {});
+    __publicField(this, "_userId", null);
+    __publicField(this, "_userTraits", {});
+    // DOM elements (for vanilla usage)
+    __publicField(this, "triggerButton", null);
+    __publicField(this, "modal", null);
+    __publicField(this, "overlay", null);
+    __publicField(this, "stylesInjected", false);
+    // Auto-close timeout reference (for cleanup on destroy)
+    __publicField(this, "autoCloseTimeout", null);
+    this.widgetId = options.widgetId;
+    this.headless = options.headless ?? false;
+    this.config = { ...DEFAULT_CONFIG, ...options.config };
+    this.apiClient = new ApiClient(
+      options.apiBaseUrl ?? DEFAULT_API_BASE_URL,
+      this.config.debug
+    );
+    this.emitter = new TypedEventEmitter();
+    this.stateSnapshot = { ...this.state };
+    this.log("Instance created", { widgetId: this.widgetId, headless: this.headless });
+  }
+  /**
+   * Initialize FeedValue
+   * Returns existing instance if already initialized for this widgetId
+   */
+  static init(options) {
+    const existing = instances.get(options.widgetId);
+    if (existing) {
+      return existing;
+    }
+    const instance = new _FeedValue(options);
+    instances.set(options.widgetId, instance);
+    instance.init().catch((error) => {
+      console.error("[FeedValue] Initialization failed:", error);
+    });
+    return instance;
+  }
+  /**
+   * Get existing instance by widgetId
+   */
+  static getInstance(widgetId) {
+    return instances.get(widgetId);
+  }
+  // ===========================================================================
+  // Lifecycle
+  // ===========================================================================
+  /**
+   * Initialize the widget
+   */
+  async init() {
+    if (this.state.isReady) {
+      this.log("Already initialized");
+      return;
+    }
+    try {
+      this.log("Initializing...");
+      const fingerprint = generateFingerprint();
+      this.apiClient.setFingerprint(fingerprint);
+      const configResponse = await this.apiClient.fetchConfig(this.widgetId);
+      this.widgetConfig = {
+        widgetId: configResponse.widget_id,
+        widgetKey: configResponse.widget_key,
+        appId: "",
+        config: {
+          position: configResponse.config.position ?? "bottom-right",
+          triggerText: configResponse.config.triggerText ?? "Feedback",
+          triggerIcon: configResponse.config.triggerIcon ?? "none",
+          formTitle: configResponse.config.formTitle ?? "Share your feedback",
+          submitButtonText: configResponse.config.submitButtonText ?? "Submit",
+          thankYouMessage: configResponse.config.thankYouMessage ?? "Thank you for your feedback!",
+          showBranding: configResponse.config.showBranding ?? true,
+          customFields: configResponse.config.customFields
+        },
+        styling: {
+          primaryColor: configResponse.styling.primaryColor ?? "#3b82f6",
+          backgroundColor: configResponse.styling.backgroundColor ?? "#ffffff",
+          textColor: configResponse.styling.textColor ?? "#1f2937",
+          buttonTextColor: configResponse.styling.buttonTextColor ?? "#ffffff",
+          borderRadius: configResponse.styling.borderRadius ?? "8px",
+          customCSS: configResponse.styling.customCSS
+        }
+      };
+      if (!this.headless && typeof window !== "undefined" && typeof document !== "undefined") {
+        this.renderWidget();
+      }
+      this.updateState({ isReady: true, error: null });
+      this.emitter.emit("ready");
+      this.log("Initialized successfully");
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.updateState({ error: err });
+      this.emitter.emit("error", err);
+      throw err;
+    }
+  }
+  /**
+   * Destroy the widget
+   */
+  destroy() {
+    this.log("Destroying...");
+    if (this.autoCloseTimeout) {
+      clearTimeout(this.autoCloseTimeout);
+      this.autoCloseTimeout = null;
+    }
+    this.triggerButton?.remove();
+    this.modal?.remove();
+    this.overlay?.remove();
+    document.getElementById("fv-widget-styles")?.remove();
+    document.getElementById("fv-widget-custom-styles")?.remove();
+    this.triggerButton = null;
+    this.modal = null;
+    this.overlay = null;
+    this.widgetConfig = null;
+    this.stateSubscribers.clear();
+    this.emitter.removeAllListeners();
+    this.apiClient.clearCache();
+    instances.delete(this.widgetId);
+    this.state = {
+      isReady: false,
+      isOpen: false,
+      isVisible: false,
+      error: null,
+      isSubmitting: false
+    };
+    this.log("Destroyed");
+  }
+  // ===========================================================================
+  // Widget Control
+  // ===========================================================================
+  open() {
+    if (!this.state.isReady) {
+      this.log("Cannot open: not ready");
+      return;
+    }
+    this.updateState({ isOpen: true });
+    if (!this.headless) {
+      this.overlay?.classList.add("fv-widget-open");
+      this.modal?.classList.add("fv-widget-open");
+    }
+    this.emitter.emit("open");
+    this.log("Opened");
+  }
+  close() {
+    this.updateState({ isOpen: false });
+    if (!this.headless) {
+      this.overlay?.classList.remove("fv-widget-open");
+      this.modal?.classList.remove("fv-widget-open");
+    }
+    this.emitter.emit("close");
+    this.log("Closed");
+  }
+  toggle() {
+    if (this.state.isOpen) {
+      this.close();
+    } else {
+      this.open();
+    }
+  }
+  show() {
+    this.updateState({ isVisible: true });
+    if (!this.headless && this.triggerButton) {
+      this.triggerButton.style.display = "";
+    }
+    this.log("Shown");
+  }
+  hide() {
+    this.updateState({ isVisible: false });
+    if (!this.headless && this.triggerButton) {
+      this.triggerButton.style.display = "none";
+    }
+    this.log("Hidden");
+  }
+  // ===========================================================================
+  // State Queries
+  // ===========================================================================
+  isOpen() {
+    return this.state.isOpen;
+  }
+  isVisible() {
+    return this.state.isVisible;
+  }
+  isReady() {
+    return this.state.isReady;
+  }
+  isHeadless() {
+    return this.headless;
+  }
+  // ===========================================================================
+  // User Data
+  // ===========================================================================
+  setData(data) {
+    this._userData = { ...this._userData, ...data };
+    this.log("User data set", data);
+  }
+  identify(userId, traits) {
+    this._userId = userId;
+    if (traits) {
+      this._userTraits = { ...this._userTraits, ...traits };
+    }
+    this.log("User identified", { userId, traits });
+  }
+  reset() {
+    this._userData = {};
+    this._userId = null;
+    this._userTraits = {};
+    this.log("User data reset");
+  }
+  /**
+   * Get current user data (for debugging/testing)
+   */
+  getUserData() {
+    return {
+      userId: this._userId,
+      data: { ...this._userData },
+      traits: { ...this._userTraits }
+    };
+  }
+  // ===========================================================================
+  // Feedback
+  // ===========================================================================
+  async submit(feedback) {
+    if (!this.state.isReady) {
+      throw new Error("Widget not ready");
+    }
+    this.validateFeedback(feedback);
+    this.updateState({ isSubmitting: true });
+    try {
+      const fullFeedback = {
+        message: feedback.message,
+        sentiment: feedback.sentiment,
+        customFieldValues: feedback.customFieldValues,
+        metadata: {
+          page_url: typeof window !== "undefined" ? window.location.href : "",
+          referrer: typeof document !== "undefined" ? document.referrer : void 0,
+          user_agent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+          ...feedback.metadata
+        }
+      };
+      const userData = this.buildSubmissionUserData();
+      await this.apiClient.submitFeedback(this.widgetId, fullFeedback, userData);
+      this.emitter.emit("submit", fullFeedback);
+      this.log("Feedback submitted", userData ? { withUserData: true } : void 0);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emitter.emit("error", err);
+      throw err;
+    } finally {
+      this.updateState({ isSubmitting: false });
+    }
+  }
+  /**
+   * Build user data object for API submission
+   * Combines data from identify() and setData() calls
+   */
+  buildSubmissionUserData() {
+    const hasUserId = this._userId !== null;
+    const hasUserData = Object.keys(this._userData).length > 0;
+    const hasTraits = Object.keys(this._userTraits).length > 0;
+    if (!hasUserId && !hasUserData && !hasTraits) {
+      return void 0;
+    }
+    const result = {};
+    if (this._userId) {
+      result.user_id = this._userId;
+    }
+    const email = this._userData.email ?? this._userTraits.email;
+    const name = this._userData.name ?? this._userTraits.name;
+    if (email) result.email = email;
+    if (name) result.name = name;
+    if (hasTraits) {
+      const { email: _e, name: _n, ...otherTraits } = this._userTraits;
+      if (Object.keys(otherTraits).length > 0) {
+        result.traits = otherTraits;
+      }
+    }
+    if (hasUserData) {
+      const { email: _e, name: _n, ...customData } = this._userData;
+      const filtered = {};
+      for (const [key, value] of Object.entries(customData)) {
+        if (value !== void 0) {
+          filtered[key] = value;
+        }
+      }
+      if (Object.keys(filtered).length > 0) {
+        result.custom_data = filtered;
+      }
+    }
+    return result;
+  }
+  /**
+   * Validate feedback data before submission
+   * @throws Error if validation fails
+   */
+  validateFeedback(feedback) {
+    if (!feedback.message?.trim()) {
+      throw new Error("Feedback message is required");
+    }
+    if (feedback.message.length > MAX_MESSAGE_LENGTH) {
+      throw new Error(`Feedback message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`);
+    }
+    if (feedback.sentiment !== void 0 && !VALID_SENTIMENTS.includes(feedback.sentiment)) {
+      throw new Error(`Invalid sentiment value. Must be one of: ${VALID_SENTIMENTS.join(", ")}`);
+    }
+    if (feedback.customFieldValues) {
+      for (const [key, value] of Object.entries(feedback.customFieldValues)) {
+        if (typeof key !== "string" || typeof value !== "string") {
+          throw new Error("Custom field values must be strings");
+        }
+      }
+    }
+    if (feedback.metadata) {
+      for (const [key, value] of Object.entries(feedback.metadata)) {
+        if (typeof value === "string" && value.length > MAX_METADATA_VALUE_LENGTH) {
+          throw new Error(`Metadata field "${key}" exceeds maximum length of ${MAX_METADATA_VALUE_LENGTH} characters`);
+        }
+      }
+    }
+  }
+  // ===========================================================================
+  // Events
+  // ===========================================================================
+  on(event, callback) {
+    this.emitter.on(event, callback);
+  }
+  /**
+   * Subscribe to an event for a single emission.
+   * The handler will be automatically removed after the first call.
+   */
+  once(event, callback) {
+    this.emitter.once(event, callback);
+  }
+  off(event, callback) {
+    this.emitter.off(event, callback);
+  }
+  /**
+   * Returns a promise that resolves when the widget is ready.
+   * Useful for programmatic initialization flows.
+   *
+   * @throws {Error} If initialization fails
+   */
+  async waitUntilReady() {
+    if (this.state.isReady) {
+      return;
+    }
+    if (this.state.error) {
+      throw this.state.error;
+    }
+    return new Promise((resolve, reject) => {
+      this.once("ready", () => resolve());
+      this.once("error", (error) => reject(error));
+    });
+  }
+  // ===========================================================================
+  // Configuration
+  // ===========================================================================
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+    this.log("Config updated", config);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get widget configuration (from API)
+   */
+  getWidgetConfig() {
+    return this.widgetConfig;
+  }
+  // ===========================================================================
+  // Framework Integration
+  // ===========================================================================
+  /**
+   * Subscribe to state changes
+   * Used by React's useSyncExternalStore
+   */
+  subscribe(callback) {
+    this.stateSubscribers.add(callback);
+    return () => {
+      this.stateSubscribers.delete(callback);
+    };
+  }
+  /**
+   * Get current state snapshot
+   * Used by React's useSyncExternalStore
+   */
+  getSnapshot() {
+    return this.stateSnapshot;
+  }
+  // ===========================================================================
+  // Internal Methods
+  // ===========================================================================
+  /**
+   * Update state and notify subscribers
+   */
+  updateState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.stateSnapshot = { ...this.state };
+    this.emitter.emit("stateChange", this.stateSnapshot);
+    for (const subscriber of this.stateSubscribers) {
+      subscriber();
+    }
+  }
+  /**
+   * Render widget DOM elements (for vanilla usage)
+   */
+  renderWidget() {
+    if (!this.widgetConfig) return;
+    if (!this.stylesInjected) {
+      this.injectStyles();
+      this.stylesInjected = true;
+    }
+    this.renderTrigger();
+    this.renderModal();
+  }
+  /**
+   * Sanitize CSS to block potentially dangerous patterns
+   * Prevents CSS injection attacks via url(), @import, and other vectors
+   */
+  sanitizeCSS(css) {
+    const BLOCKED_PATTERNS = [
+      /url\s*\(/gi,
+      // External resources
+      /@import/gi,
+      // External stylesheets
+      /expression\s*\(/gi,
+      // IE expressions
+      /javascript:/gi,
+      // JavaScript URLs
+      /behavior\s*:/gi,
+      // IE behaviors
+      /-moz-binding/gi
+      // Firefox XBL
+    ];
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (pattern.test(css)) {
+        console.warn("[FeedValue] Blocked potentially unsafe CSS pattern");
+        return "";
+      }
+    }
+    return css;
+  }
+  /**
+   * Inject CSS styles
+   */
+  injectStyles() {
+    if (!this.widgetConfig) return;
+    const { styling, config } = this.widgetConfig;
+    const styleEl = document.createElement("style");
+    styleEl.id = "fv-widget-styles";
+    styleEl.textContent = this.getBaseStyles(styling, config.position);
+    document.head.appendChild(styleEl);
+    if (styling.customCSS) {
+      const sanitizedCSS = this.sanitizeCSS(styling.customCSS);
+      if (sanitizedCSS) {
+        const customStyleEl = document.createElement("style");
+        customStyleEl.id = "fv-widget-custom-styles";
+        customStyleEl.textContent = sanitizedCSS;
+        document.head.appendChild(customStyleEl);
+      }
+    }
+  }
+  /**
+   * Get base CSS styles
+   */
+  getBaseStyles(styling, position) {
+    const positionStyles = this.getPositionStyles(position);
+    const modalPositionStyles = this.getModalPositionStyles(position);
+    return `
+      .fv-widget-trigger {
+        position: fixed;
+        ${positionStyles}
+        background-color: ${styling.primaryColor};
+        color: ${styling.buttonTextColor};
+        padding: 12px 24px;
+        border-radius: ${styling.borderRadius};
+        cursor: pointer;
+        z-index: 9998;
+        font-family: system-ui, -apple-system, sans-serif;
+        font-size: 14px;
+        font-weight: 500;
+        border: none;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        transition: transform 0.2s, box-shadow 0.2s;
+      }
+      .fv-widget-trigger:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15);
+      }
+      .fv-widget-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background-color: rgba(0, 0, 0, 0.5);
+        z-index: 9998;
+        display: none;
+        backdrop-filter: blur(4px);
+      }
+      .fv-widget-overlay.fv-widget-open {
+        display: block;
+      }
+      .fv-widget-modal {
+        position: fixed;
+        ${modalPositionStyles}
+        background-color: ${styling.backgroundColor};
+        color: ${styling.textColor};
+        border-radius: ${styling.borderRadius};
+        padding: 24px;
+        max-width: 500px;
+        width: 90%;
+        max-height: 90vh;
+        overflow-y: auto;
+        z-index: 9999;
+        display: none;
+        box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1);
+        font-family: system-ui, -apple-system, sans-serif;
+      }
+      .fv-widget-modal.fv-widget-open {
+        display: block;
+      }
+      .fv-widget-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 20px;
+      }
+      .fv-widget-title {
+        font-size: 20px;
+        font-weight: 600;
+        margin: 0;
+      }
+      .fv-widget-close {
+        background: transparent;
+        border: none;
+        font-size: 24px;
+        cursor: pointer;
+        color: ${styling.textColor};
+        padding: 0;
+        width: 32px;
+        height: 32px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }
+      .fv-widget-form {
+        display: flex;
+        flex-direction: column;
+        gap: 16px;
+      }
+      .fv-widget-textarea {
+        width: 100%;
+        min-height: 120px;
+        padding: 12px;
+        border: 1px solid rgba(0, 0, 0, 0.2);
+        border-radius: ${styling.borderRadius};
+        font-family: system-ui, -apple-system, sans-serif;
+        font-size: 14px;
+        resize: vertical;
+        box-sizing: border-box;
+        background-color: ${styling.backgroundColor};
+        color: ${styling.textColor};
+      }
+      .fv-widget-textarea:focus {
+        outline: none;
+        border-color: ${styling.primaryColor};
+        box-shadow: 0 0 0 2px ${styling.primaryColor}33;
+      }
+      .fv-widget-submit {
+        background-color: ${styling.primaryColor};
+        color: ${styling.buttonTextColor};
+        padding: 12px 24px;
+        border: none;
+        border-radius: ${styling.borderRadius};
+        font-size: 14px;
+        font-weight: 500;
+        cursor: pointer;
+        transition: opacity 0.2s;
+      }
+      .fv-widget-submit:hover:not(:disabled) {
+        opacity: 0.9;
+      }
+      .fv-widget-submit:disabled {
+        opacity: 0.5;
+        cursor: not-allowed;
+      }
+      .fv-widget-error {
+        color: #ef4444;
+        font-size: 14px;
+        margin-top: 8px;
+        display: none;
+      }
+      .fv-widget-branding {
+        text-align: center;
+        font-size: 12px;
+        color: ${styling.textColor};
+        margin-top: 16px;
+        opacity: 0.7;
+      }
+      .fv-widget-branding a {
+        color: ${styling.primaryColor};
+        text-decoration: none;
+      }
+    `;
+  }
+  /**
+   * Get trigger button position styles
+   */
+  getPositionStyles(position) {
+    switch (position) {
+      case "bottom-left":
+        return "bottom: 20px; left: 20px;";
+      case "top-right":
+        return "top: 20px; right: 20px;";
+      case "top-left":
+        return "top: 20px; left: 20px;";
+      case "center":
+        return "top: 50%; left: 50%; transform: translate(-50%, -50%);";
+      case "bottom-right":
+      default:
+        return "bottom: 20px; right: 20px;";
+    }
+  }
+  /**
+   * Get modal position styles
+   */
+  getModalPositionStyles(position) {
+    switch (position) {
+      case "bottom-left":
+        return "bottom: 20px; left: 20px;";
+      case "bottom-right":
+        return "bottom: 20px; right: 20px;";
+      case "top-right":
+        return "top: 20px; right: 20px;";
+      case "top-left":
+        return "top: 20px; left: 20px;";
+      case "center":
+      default:
+        return "top: 50%; left: 50%; transform: translate(-50%, -50%);";
+    }
+  }
+  /**
+   * Render trigger button using safe DOM methods
+   */
+  renderTrigger() {
+    if (!this.widgetConfig) return;
+    this.triggerButton = document.createElement("button");
+    this.triggerButton.className = "fv-widget-trigger";
+    this.triggerButton.textContent = this.widgetConfig.config.triggerText;
+    this.triggerButton.addEventListener("click", () => this.open());
+    document.body.appendChild(this.triggerButton);
+  }
+  /**
+   * Render modal using safe DOM methods (no innerHTML)
+   */
+  renderModal() {
+    if (!this.widgetConfig) return;
+    const { config } = this.widgetConfig;
+    this.overlay = document.createElement("div");
+    this.overlay.className = "fv-widget-overlay";
+    this.overlay.addEventListener("click", () => this.close());
+    document.body.appendChild(this.overlay);
+    this.modal = document.createElement("div");
+    this.modal.className = "fv-widget-modal";
+    const header = document.createElement("div");
+    header.className = "fv-widget-header";
+    const title = document.createElement("h2");
+    title.className = "fv-widget-title";
+    title.textContent = config.formTitle;
+    header.appendChild(title);
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "fv-widget-close";
+    closeBtn.setAttribute("aria-label", "Close");
+    closeBtn.textContent = "\xD7";
+    closeBtn.addEventListener("click", () => this.close());
+    header.appendChild(closeBtn);
+    this.modal.appendChild(header);
+    const form = document.createElement("form");
+    form.className = "fv-widget-form";
+    form.id = "fv-feedback-form";
+    const textarea = document.createElement("textarea");
+    textarea.className = "fv-widget-textarea";
+    textarea.id = "fv-feedback-content";
+    textarea.placeholder = "Tell us what you think...";
+    textarea.required = true;
+    form.appendChild(textarea);
+    const submitBtn = document.createElement("button");
+    submitBtn.type = "submit";
+    submitBtn.className = "fv-widget-submit";
+    submitBtn.textContent = config.submitButtonText;
+    form.appendChild(submitBtn);
+    const errorDiv = document.createElement("div");
+    errorDiv.className = "fv-widget-error";
+    errorDiv.id = "fv-error-message";
+    form.appendChild(errorDiv);
+    form.addEventListener("submit", (e) => this.handleFormSubmit(e));
+    this.modal.appendChild(form);
+    if (config.showBranding) {
+      const branding = document.createElement("div");
+      branding.className = "fv-widget-branding";
+      const brandText = document.createTextNode("Powered by ");
+      branding.appendChild(brandText);
+      const link = document.createElement("a");
+      link.href = "https://feedvalue.com";
+      link.target = "_blank";
+      link.rel = "noopener noreferrer";
+      link.textContent = "FeedValue";
+      branding.appendChild(link);
+      this.modal.appendChild(branding);
+    }
+    document.body.appendChild(this.modal);
+  }
+  /**
+   * Handle form submission
+   */
+  async handleFormSubmit(event) {
+    event.preventDefault();
+    const textarea = document.getElementById("fv-feedback-content");
+    const submitBtn = this.modal?.querySelector(".fv-widget-submit");
+    const errorEl = document.getElementById("fv-error-message");
+    if (!textarea?.value.trim()) {
+      this.showError("Please enter your feedback");
+      return;
+    }
+    try {
+      submitBtn.disabled = true;
+      submitBtn.textContent = "Submitting...";
+      if (errorEl) errorEl.style.display = "none";
+      await this.submit({ message: textarea.value.trim() });
+      this.showSuccess();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Failed to submit";
+      this.showError(message);
+    } finally {
+      submitBtn.disabled = false;
+      submitBtn.textContent = this.widgetConfig?.config.submitButtonText ?? "Submit";
+    }
+  }
+  /**
+   * Show error message (safe - uses textContent)
+   */
+  showError(message) {
+    const errorEl = document.getElementById("fv-error-message");
+    if (errorEl) {
+      errorEl.textContent = message;
+      errorEl.style.display = "block";
+    }
+  }
+  /**
+   * Show success message using safe DOM methods
+   */
+  showSuccess() {
+    if (!this.modal || !this.widgetConfig) return;
+    if (this.autoCloseTimeout) {
+      clearTimeout(this.autoCloseTimeout);
+      this.autoCloseTimeout = null;
+    }
+    this.modal.textContent = "";
+    const successDiv = document.createElement("div");
+    successDiv.style.cssText = "text-align: center; padding: 40px 20px;";
+    const iconDiv = document.createElement("div");
+    iconDiv.style.cssText = "font-size: 48px; margin-bottom: 16px;";
+    iconDiv.textContent = "\u2713";
+    successDiv.appendChild(iconDiv);
+    const messageDiv = document.createElement("div");
+    messageDiv.style.cssText = "font-size: 16px; margin-bottom: 24px;";
+    messageDiv.textContent = this.widgetConfig.config.thankYouMessage;
+    successDiv.appendChild(messageDiv);
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "fv-widget-submit";
+    closeBtn.textContent = "Close";
+    closeBtn.addEventListener("click", () => {
+      this.close();
+      this.resetForm();
+    });
+    successDiv.appendChild(closeBtn);
+    this.modal.appendChild(successDiv);
+    this.autoCloseTimeout = setTimeout(() => {
+      if (this.state.isOpen) {
+        this.close();
+        this.resetForm();
+      }
+      this.autoCloseTimeout = null;
+    }, SUCCESS_AUTO_CLOSE_DELAY_MS);
+  }
+  /**
+   * Reset form to initial state
+   */
+  resetForm() {
+    if (!this.modal) return;
+    this.modal.textContent = "";
+    this.modal.remove();
+    this.modal = null;
+    this.renderModal();
+  }
+  /**
+   * Debug logging
+   */
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[FeedValue] ${message}`, data ?? "");
+    }
+  }
+};
+
+exports.ApiClient = ApiClient;
+exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+exports.FeedValue = FeedValue;
+exports.TypedEventEmitter = TypedEventEmitter;
+exports.clearFingerprint = clearFingerprint;
+exports.generateFingerprint = generateFingerprint;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map