@cognior/iap-sdk 0.1.0

package/src/http.ts

@@ -0,0 +1,61 @@
+// src/http.ts
+// Tiny fetch wrapper with headers, JSON body, timeout and better error shape.
+
+import type { DapConfig } from "./config";
+
+export type HttpOptions = {
+  method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  headers?: Record<string, string>;
+  body?: any;                // will be JSON-stringified if provided and method != GET
+  hostBase?: string;         // used for X-Host-Url
+  includeHostHeader?: boolean;
+  timeoutMs?: number;
+};
+
+export async function http(cfg: DapConfig, path: string, opts: HttpOptions = {}): Promise<any> {
+  const method = (opts.method || "GET").toUpperCase() as HttpOptions["method"];
+  const headers: Record<string, string> = {
+    "X-Api-Key": cfg.apikey,
+    ...(opts.includeHostHeader && opts.hostBase ? { "X-Host-Url": opts.hostBase } : {}),
+    ...(opts.headers || {}),
+  };
+
+  // Only attach JSON body for non-GET
+  let bodyInit: BodyInit | undefined;
+  if (method !== "GET" && opts.body !== undefined) {
+    headers["Content-Type"] = headers["Content-Type"] || "application/json";
+    bodyInit = JSON.stringify(opts.body);
+  }
+
+  // IMPORTANT: do NOT prefix '/api' here; use the path as given.
+  const url = isAbsoluteUrl(path) ? path : new URL(path, location.origin).toString();
+
+  // Timeout support
+  const c = new AbortController();
+  const t = setTimeout(() => c.abort(), opts.timeoutMs ?? 15000);
+
+  let res: Response;
+  try {
+    res = await fetch(url, { method, headers, body: bodyInit, signal: c.signal, credentials: "omit", cache: "no-cache" });
+  } catch (err) {
+    clearTimeout(t);
+    throw err;
+  }
+  clearTimeout(t);
+
+  if (!res.ok) {
+    const e = new Error(`HTTP ${res.status}`);
+    (e as any).status = res.status;
+    try { (e as any).body = await res.text(); } catch {}
+    throw e;
+  }
+
+  const ct = res.headers.get("content-type") || "";
+  if (ct.includes("application/json")) return res.json();
+  if (ct.startsWith("text/")) return res.text();
+  return res;
+}
+
+function isAbsoluteUrl(u: string): boolean {
+  return /^https?:\/\//i.test(u) || u.startsWith("blob:") || u.startsWith("data:");
+}

package/src/index.ts

@@ -0,0 +1,355 @@
+// src/index.ts - Completely refactored DAP SDK
+
+// CRITICAL: Import immediate validation prevention FIRST
+import "./utils/immediateValidationPrevention";
+
+import type { DapConfig } from "./config";
+import {
+  fetchVisibleFlowIds,
+  fetchFlowById,
+} from "./flows";
+import { registerModalSequence } from "./experiences/modalSequence";
+import { registerModal, renderModal } from "./experiences/modal";
+import { registerTooltip } from "./experiences/tooltip";
+import { registerSurvey } from "./experiences/survey";
+import { registerPopover } from "./experiences/popover";
+import { registerBeacon } from "./experiences/beacon";
+import { registerBanner } from "./experiences/banner";
+import { registerHotspots } from "./experiences/hotspots";
+import { registerHotspotTour } from "./experiences/hotspotTour";
+import { registerTaskList } from "./experiences/taskList";
+import { registerWalkthrough } from "./experiences/walkthrough";
+import { LocationContextService } from "./services/locationContextService";
+import { userContextService, type DapUser } from "./services/userContextService";
+import { flowEngine } from "./core/flowEngine";
+import type { FlowData } from "./core/flowEngine";
+import { ValidationInterceptor } from "./utils/validationInterceptor";
+
+// Initialize validation interceptor for DAP tooltip replacement
+const validationInterceptor = ValidationInterceptor.getInstance();
+
+// Register all experience renderers
+registerModalSequence();
+registerModal();
+registerTooltip();
+registerSurvey(); // Now handles both modal surveys and micro surveys
+registerPopover();
+registerBeacon();
+registerBanner();
+registerHotspots();
+registerHotspotTour();
+registerTaskList();
+registerWalkthrough();
+
+const log = (...args: any[]) =>
+  (window as any).__DAP_DEBUG__ ? console.log("[DAP]", ...args) : void 0;
+
+// Global storage for SDK state  
+let _dapConfig: DapConfig | null = null;
+let _flowInitializationPending = false;
+let _pendingFlowIds: string[] = [];
+let _registeredFlows: Map<string, FlowData> = new Map(); // Store registered flows in memory
+
+/**
+ * Initialize DAP SDK with optional user context
+ */
+export async function init(opts: { 
+  configUrl: string; 
+  debug?: boolean; 
+  screenId?: string;
+  user?: DapUser;
+}) {
+  const { configUrl, debug, screenId, user } = opts || ({} as any);
+  (window as any).__DAP_DEBUG__ = !!debug;
+
+  if (!configUrl) throw new Error("DAP.init: configUrl is required");
+  
+  // Extract the pathname for location context
+  const pathname = location.pathname.replace(/^\/+/, '');
+  const cfg = await loadConfig(configUrl);
+  const hostBase = location.origin;
+
+  // Store config globally
+  (window as any).__DAP_CONFIG__ = cfg;
+  _dapConfig = cfg;
+
+  // Set user context if provided
+  if (user) {
+    userContextService.setUser(user);
+    log("User context set during init:", user.id);
+  }
+
+  log("Loaded config", { cfg, hostBase });
+  
+  // Initialize validation interceptor for DAP tooltip replacement (prevention handled elsewhere)
+  validationInterceptor.initialize();
+  
+  // Set up location context with current pathname and screenId if provided
+  const locationService = LocationContextService.getInstance();
+  locationService.setContext({
+    currentPath: pathname,
+    screenId: screenId || pathname
+  });
+  
+  log("Location context set", locationService.getContext());
+
+  // 1) Get visible flow IDs
+  const ids = await fetchVisibleFlowIds(cfg, hostBase, pathname);
+  log("Visible flow IDs", ids);
+
+  if (ids.length === 0) {
+    log("No flows available");
+    return;
+  }
+
+  // Store pending flow IDs for later initialization
+  _pendingFlowIds = ids;
+  
+  // Initialize flows based on readiness state
+  await initializeFlowsWhenReady();
+}
+
+async function loadConfig(configUrl: string): Promise<DapConfig> {
+  const res = await fetch(configUrl);
+  if (!res.ok) throw new Error(`Failed to load config: ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Initialize flows when system is ready
+ * Waits for DOM readiness and handles user context requirements
+ */
+async function initializeFlowsWhenReady(): Promise<void> {
+  if (_flowInitializationPending) {
+    log("Flow initialization already pending");
+    return;
+  }
+
+  _flowInitializationPending = true;
+
+  // Wait for DOM to be ready
+  await waitForDOMReady();
+
+  // Check if we should proceed with flow initialization
+  if (!shouldInitializeFlows()) {
+    log("Flow initialization deferred - waiting for user context");
+    return;
+  }
+
+  await startPendingFlows();
+}
+
+/**
+ * Wait for DOM to be ready
+ */
+async function waitForDOMReady(): Promise<void> {
+  return new Promise((resolve) => {
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', () => resolve());
+    } else {
+      resolve();
+    }
+  });
+}
+
+/**
+ * Determine if flows should initialize now
+ */
+function shouldInitializeFlows(): boolean {
+  // Always allow if user context is available
+  if (userContextService.hasRealUser()) {
+    log("Flow initialization allowed - real user context available");
+    return true;
+  }
+
+  // For now, allow anonymous flows (can be made more restrictive)
+  log("Flow initialization allowed - proceeding with anonymous context");
+  return true;
+}
+
+/**
+ * Start pending flows
+ */
+async function startPendingFlows(): Promise<void> {
+  if (!_dapConfig || _pendingFlowIds.length === 0) {
+    log("No pending flows to start");
+    _flowInitializationPending = false;
+    return;
+  }
+
+  try {
+    const firstFlowId = _pendingFlowIds[0];
+    log(`Starting first flow: ${firstFlowId}`);
+    
+    const rawFlowData = await fetchFlowById(_dapConfig, location.origin, firstFlowId);
+    console.debug(`[DAP] Raw flow data received:`, rawFlowData);
+    
+    const flowData: FlowData = {
+      flowId: rawFlowData.flowId,
+      flowName: rawFlowData.flowName || rawFlowData.name || firstFlowId,
+      steps: rawFlowData.steps || []
+    };
+    
+    console.debug(`[DAP] Converted flow data:`, flowData);
+    log("Starting flow with engine:", flowData);
+    
+    await flowEngine.startFlow(flowData);
+    
+  } catch (err) {
+    console.error("[DAP] Failed to start initial flow", err);
+  } finally {
+    _flowInitializationPending = false;
+  }
+}
+
+/**
+ * Set user context and trigger flow re-evaluation
+ */
+export function setUser(user: DapUser): void {
+  userContextService.setUser(user);
+  
+  // If flows were waiting for user context, start them now
+  if (_pendingFlowIds.length > 0 && !_flowInitializationPending) {
+    log("User context set - starting pending flows");
+    initializeFlowsWhenReady();
+  }
+}
+
+/**
+ * Update existing user context
+ */
+export function updateUser(partialUser: Partial<DapUser>): void {
+  userContextService.updateUser(partialUser);
+}
+
+/**
+ * Get current user context
+ */
+export function getUser(): DapUser | null {
+  return userContextService.getUser();
+}
+
+/**
+ * Clear user context
+ */
+export function clearUser(): void {
+  userContextService.clearUser();
+}
+
+function joinUrl(base: string, path: string): string {
+  return base.replace(/\/$/, '') + '/' + path.replace(/^\//, '');
+}
+
+import { resolveSelector } from './utils/selectors';
+
+// Minimal API for backwards compatibility
+export function runModalSequence() {
+  console.warn("[DAP] runModalSequence is deprecated, flows are managed by FlowEngine");
+}
+
+// New API for executing custom flows (useful for testing and dynamic flows)
+export async function executeFlow(flow: any): Promise<void> {
+  if (!flow || !flow.id || !flow.steps) {
+    throw new Error("Invalid flow object: must have 'id' and 'steps' properties");
+  }
+  
+  // Normalize the flow from test format to FlowData format
+  const normalizedFlow: FlowData = {
+    flowId: flow.id,
+    flowName: flow.name || flow.id,
+    steps: flow.steps.map((step: any, index: number) => ({
+      stepId: step.id || `step-${index + 1}`,
+      stepOrder: index + 1,
+      uxExperience: {
+        uxExperienceType: step.type,
+        elementSelector: step.trigger?.selector,
+        elementTrigger: step.trigger?.type || 'immediate',
+        elementLocation: step.trigger?.placement || 'auto',
+        content: step.content
+      }
+    }))
+  };
+  
+  log("Executing custom flow:", normalizedFlow);
+  return flowEngine.startFlow(normalizedFlow);
+}
+
+/**
+ * Register a flow for later execution by ID
+ */
+export function registerFlow(flowData: FlowData): void {
+  _registeredFlows.set(flowData.flowId, flowData);
+  log("Flow registered:", flowData.flowId);
+}
+
+/**
+ * Start a flow by ID (from registered flows or backend)
+ */
+export async function startFlow(flowId: string): Promise<void> {
+  // First check if flow is registered in memory
+  const registeredFlow = _registeredFlows.get(flowId);
+  if (registeredFlow) {
+    log("Starting registered flow:", flowId);
+    return flowEngine.startFlow(registeredFlow);
+  }
+
+  // If not found in memory, try to fetch from backend
+  if (!_dapConfig) {
+    throw new Error("SDK not initialized. Call init() first or register the flow using registerFlow()");
+  }
+
+  try {
+    const rawFlowData = await fetchFlowById(_dapConfig, location.origin, flowId);
+    const flowData: FlowData = {
+      flowId: rawFlowData.flowId,
+      flowName: rawFlowData.flowName || flowId,
+      steps: rawFlowData.steps || []
+    };
+    log("Starting flow from backend:", flowId);
+    return flowEngine.startFlow(flowData);
+  } catch (error) {
+    throw new Error(`Flow not found: ${flowId}. Make sure to register it first or check if it exists in the backend.`);
+  }
+}
+
+// Expose core services for debugging
+if (typeof window !== "undefined") {
+  (window as any).DAP = { 
+    init,
+    executeFlow, // Add executeFlow to public API
+    registerFlow, // Add registerFlow to public API
+    startFlow, // Add startFlow to public API
+    // User context APIs
+    setUser,
+    updateUser,
+    getUser,
+    clearUser,
+    // Core services
+    locationContext: LocationContextService.getInstance(),
+    userContext: userContextService,
+    flowEngine,
+    // Debug methods
+    getFlowState: () => flowEngine.getState(),
+    getUserState: () => userContextService.getDebugState(),
+    resolveSelector, // Expose for testing
+    // Development utilities (only in debug mode)
+    ...(typeof (window as any).__DAP_DEBUG__ !== 'undefined' && (window as any).__DAP_DEBUG__ ? {
+      testFlow: async (flowId: string) => {
+        if (!_dapConfig) throw new Error("SDK not initialized");
+        const rawFlowData = await fetchFlowById(_dapConfig, location.origin, flowId);
+        const flowData: FlowData = {
+          flowId: rawFlowData.flowId,
+          flowName: rawFlowData.flowName || flowId,
+          steps: rawFlowData.steps || []
+        };
+        return flowEngine.startFlow(flowData);
+      },
+      renderModal  // Add for testing
+    } : {
+      renderModal  // Always available for testing draggable functionality
+    })
+  };
+}
+
+// Export types for external use
+export type { DapUser } from "./services/userContextService";