@landform.io/sdk 0.1.2

package/dist/api/index.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+require('../chunk-52W6RI6C.cjs');
+var chunkP2GUKJHH_cjs = require('../chunk-P2GUKJHH.cjs');
+
+
+
+Object.defineProperty(exports, "LandformClient", {
+  enumerable: true,
+  get: function () { return chunkP2GUKJHH_cjs.LandformClient; }
+});
+Object.defineProperty(exports, "createClient", {
+  enumerable: true,
+  get: function () { return chunkP2GUKJHH_cjs.createClient; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/api/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/api/index.d.cts

@@ -0,0 +1,48 @@
+import { a3 as ResponseAnswers, a9 as ResponseOutcome, aa as ResponseMetadata } from '../index-DoRZImTl.cjs';
+
+interface LandformClientConfig {
+    baseUrl?: string;
+    projectId: string;
+    onError?: (error: Error) => void;
+}
+interface StartResponseParams {
+    sessionId?: string;
+    metadata?: ResponseMetadata;
+    hiddenFields?: Record<string, string>;
+}
+interface StartResponseResult {
+    id: string;
+    sessionId: string;
+}
+interface UpdateAnswersParams {
+    responseId: string;
+    sessionId: string;
+    answers: ResponseAnswers;
+    lastFieldRef?: string;
+    calculatedValues?: Record<string, number>;
+}
+interface CompleteResponseParams {
+    responseId: string;
+    sessionId: string;
+    answers?: ResponseAnswers;
+    outcome?: ResponseOutcome;
+    calculatedValues?: Record<string, number>;
+    captchaToken?: string;
+}
+interface TrackEventParams {
+    event: "view" | "start";
+    sessionId?: string;
+}
+declare class LandformClient {
+    private baseUrl;
+    private projectId;
+    private onError?;
+    constructor(config: LandformClientConfig);
+    startResponse(params?: StartResponseParams): Promise<StartResponseResult>;
+    updateAnswers(params: UpdateAnswersParams): Promise<void>;
+    completeResponse(params: CompleteResponseParams): Promise<void>;
+    trackEvent(params: TrackEventParams): Promise<void>;
+}
+declare function createClient(config: LandformClientConfig): LandformClient;
+
+export { type CompleteResponseParams, LandformClient, type LandformClientConfig, type StartResponseParams, type StartResponseResult, type UpdateAnswersParams, createClient };

package/dist/api/index.d.ts

@@ -0,0 +1,48 @@
+import { a3 as ResponseAnswers, a9 as ResponseOutcome, aa as ResponseMetadata } from '../index-DoRZImTl.js';
+
+interface LandformClientConfig {
+    baseUrl?: string;
+    projectId: string;
+    onError?: (error: Error) => void;
+}
+interface StartResponseParams {
+    sessionId?: string;
+    metadata?: ResponseMetadata;
+    hiddenFields?: Record<string, string>;
+}
+interface StartResponseResult {
+    id: string;
+    sessionId: string;
+}
+interface UpdateAnswersParams {
+    responseId: string;
+    sessionId: string;
+    answers: ResponseAnswers;
+    lastFieldRef?: string;
+    calculatedValues?: Record<string, number>;
+}
+interface CompleteResponseParams {
+    responseId: string;
+    sessionId: string;
+    answers?: ResponseAnswers;
+    outcome?: ResponseOutcome;
+    calculatedValues?: Record<string, number>;
+    captchaToken?: string;
+}
+interface TrackEventParams {
+    event: "view" | "start";
+    sessionId?: string;
+}
+declare class LandformClient {
+    private baseUrl;
+    private projectId;
+    private onError?;
+    constructor(config: LandformClientConfig);
+    startResponse(params?: StartResponseParams): Promise<StartResponseResult>;
+    updateAnswers(params: UpdateAnswersParams): Promise<void>;
+    completeResponse(params: CompleteResponseParams): Promise<void>;
+    trackEvent(params: TrackEventParams): Promise<void>;
+}
+declare function createClient(config: LandformClientConfig): LandformClient;
+
+export { type CompleteResponseParams, LandformClient, type LandformClientConfig, type StartResponseParams, type StartResponseResult, type UpdateAnswersParams, createClient };

package/dist/api/index.js

@@ -0,0 +1,4 @@
+import '../chunk-GVOTY5NG.js';
+export { LandformClient, createClient } from '../chunk-PKHTPGWQ.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/chunk-52W6RI6C.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=chunk-52W6RI6C.cjs.map
+//# sourceMappingURL=chunk-52W6RI6C.cjs.map

package/dist/chunk-52W6RI6C.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-52W6RI6C.cjs"}

package/dist/chunk-DASQI7IA.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=chunk-DASQI7IA.cjs.map
+//# sourceMappingURL=chunk-DASQI7IA.cjs.map

package/dist/chunk-DASQI7IA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-DASQI7IA.cjs"}

package/dist/chunk-EL7YGOTY.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=chunk-EL7YGOTY.js.map
+//# sourceMappingURL=chunk-EL7YGOTY.js.map

package/dist/chunk-EL7YGOTY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-EL7YGOTY.js"}

package/dist/chunk-GVOTY5NG.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=chunk-GVOTY5NG.js.map
+//# sourceMappingURL=chunk-GVOTY5NG.js.map

package/dist/chunk-GVOTY5NG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-GVOTY5NG.js"}

package/dist/chunk-HUIMGLDC.js

@@ -0,0 +1,488 @@
+import { generateThemeCSS, generateComponentStyles, isBrowser, injectThemeCSS } from './chunk-PDUJU32P.js';
+import { LandformClient } from './chunk-PKHTPGWQ.js';
+import { createContext, useState, useMemo, useRef, useEffect, useCallback, useContext } from 'react';
+import { nanoid } from 'nanoid';
+
+// src/utils/storage.ts
+var AUTOSAVE_PREFIX = "lf-autosave-";
+var SUBMITTED_PREFIX = "lf-submitted-";
+var COOKIE_CONSENT_KEY = "lf-cookie-consent";
+function saveProgress(projectId, answers, currentIndex, responseId) {
+  if (typeof window === "undefined") return;
+  try {
+    const data = {
+      answers,
+      currentIndex,
+      responseId,
+      timestamp: Date.now()
+    };
+    localStorage.setItem(AUTOSAVE_PREFIX + projectId, JSON.stringify(data));
+  } catch (error) {
+    console.error("Error saving form progress:", error);
+  }
+}
+function loadProgress(projectId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = localStorage.getItem(AUTOSAVE_PREFIX + projectId);
+    if (!stored) return null;
+    const data = JSON.parse(stored);
+    const maxAge = 7 * 24 * 60 * 60 * 1e3;
+    if (Date.now() - data.timestamp > maxAge) {
+      clearProgress(projectId);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("Error loading form progress:", error);
+    return null;
+  }
+}
+function clearProgress(projectId) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.removeItem(AUTOSAVE_PREFIX + projectId);
+  } catch (error) {
+    console.error("Error clearing form progress:", error);
+  }
+}
+function markAsSubmitted(projectId) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(SUBMITTED_PREFIX + projectId, String(Date.now()));
+  } catch (error) {
+    console.error("Error marking form as submitted:", error);
+  }
+}
+function hasSubmitted(projectId) {
+  if (typeof window === "undefined") return false;
+  try {
+    return localStorage.getItem(SUBMITTED_PREFIX + projectId) !== null;
+  } catch (error) {
+    console.error("Error checking submission status:", error);
+    return false;
+  }
+}
+function hasCookieConsent() {
+  if (typeof window === "undefined") return false;
+  try {
+    return localStorage.getItem(COOKIE_CONSENT_KEY) === "true";
+  } catch (error) {
+    console.error("Error checking cookie consent:", error);
+    return false;
+  }
+}
+function setCookieConsent(consented) {
+  if (typeof window === "undefined") return;
+  try {
+    if (consented) {
+      localStorage.setItem(COOKIE_CONSENT_KEY, "true");
+    } else {
+      localStorage.removeItem(COOKIE_CONSENT_KEY);
+    }
+  } catch (error) {
+    console.error("Error setting cookie consent:", error);
+  }
+}
+
+// src/hooks/useForm.ts
+function validateFieldValue(field, value) {
+  if (!field.validations?.required) {
+    return true;
+  }
+  if (value === void 0 || value === null || value === "") {
+    return false;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return false;
+  }
+  return true;
+}
+function useForm(options) {
+  const {
+    projectId,
+    content,
+    settings,
+    baseUrl = "",
+    initialAnswers = {},
+    onComplete,
+    onError
+  } = options;
+  const [responseId, setResponseId] = useState(null);
+  const [sessionId] = useState(() => nanoid());
+  const [currentIndex, setCurrentIndex] = useState(0);
+  const [answers, setAnswers] = useState(initialAnswers);
+  const [errors, setErrors] = useState({});
+  const [isStarted, setIsStarted] = useState(false);
+  const [isCompleted, setIsCompleted] = useState(false);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [isDuplicateSubmission, setIsDuplicateSubmission] = useState(false);
+  const [captchaToken, setCaptchaToken] = useState(null);
+  const [showCaptcha, setShowCaptcha] = useState(false);
+  const client = useMemo(
+    () => new LandformClient({ baseUrl, projectId, onError }),
+    [baseUrl, projectId, onError]
+  );
+  const hasTrackedView = useRef(false);
+  const hasLoadedProgress = useRef(false);
+  const autosaveTimeoutRef = useRef(null);
+  useEffect(() => {
+    if (!hasTrackedView.current) {
+      hasTrackedView.current = true;
+      client.trackEvent({ event: "view", sessionId });
+    }
+  }, [client, sessionId]);
+  useEffect(() => {
+    if (settings.duplicatePrevention && hasSubmitted(projectId)) {
+      setIsDuplicateSubmission(true);
+    }
+  }, [projectId, settings.duplicatePrevention]);
+  useEffect(() => {
+    if (hasLoadedProgress.current || !settings.autosaveProgress) return;
+    hasLoadedProgress.current = true;
+    const savedProgress = loadProgress(projectId);
+    if (savedProgress) {
+      setAnswers(savedProgress.answers);
+      setCurrentIndex(savedProgress.currentIndex);
+      if (savedProgress.responseId) {
+        setResponseId(savedProgress.responseId);
+        setIsStarted(true);
+      }
+    }
+  }, [projectId, settings.autosaveProgress]);
+  useEffect(() => {
+    if (!settings.autosaveProgress || isCompleted) return;
+    if (autosaveTimeoutRef.current) {
+      clearTimeout(autosaveTimeoutRef.current);
+    }
+    autosaveTimeoutRef.current = setTimeout(() => {
+      saveProgress(projectId, answers, currentIndex, responseId);
+    }, 500);
+    return () => {
+      if (autosaveTimeoutRef.current) {
+        clearTimeout(autosaveTimeoutRef.current);
+      }
+    };
+  }, [projectId, answers, currentIndex, responseId, settings.autosaveProgress, isCompleted]);
+  const sequence = useMemo(() => {
+    const items = [];
+    for (const screen of content.welcomeScreens) {
+      items.push({ type: "welcome", screen });
+    }
+    content.fields.forEach((field, index) => {
+      items.push({ type: "field", field, index });
+    });
+    for (const screen of content.thankYouScreens) {
+      items.push({ type: "thankYou", screen });
+    }
+    return items;
+  }, [content]);
+  const currentItem = sequence[currentIndex] || null;
+  const totalFields = content.fields.length;
+  const answeredCount = Object.keys(answers).length;
+  const progress = totalFields > 0 ? answeredCount / totalFields * 100 : 0;
+  const firstFieldIndex = content.welcomeScreens.length;
+  const lastFieldIndex = firstFieldIndex + content.fields.length - 1;
+  const canGoBack = currentIndex > firstFieldIndex;
+  const canGoNext = currentIndex < sequence.length - 1;
+  const isOnWelcome = currentItem?.type === "welcome";
+  const isOnThankYou = currentItem?.type === "thankYou";
+  const isOnField = currentItem?.type === "field";
+  const start = useCallback(async () => {
+    try {
+      const result = await client.startResponse({ sessionId });
+      setResponseId(result.id);
+      setIsStarted(true);
+      client.trackEvent({ event: "start", sessionId });
+      if (currentItem?.type === "welcome") {
+        setCurrentIndex((prev) => prev + 1);
+      }
+    } catch (error) {
+      onError?.(error);
+    }
+  }, [client, sessionId, currentItem, onError]);
+  const validateCurrentWithValue = useCallback((pendingValue) => {
+    if (currentItem?.type !== "field") return true;
+    const field = currentItem.field;
+    const value = pendingValue !== void 0 ? pendingValue : answers[field.ref];
+    const isValid = validateFieldValue(field, value);
+    if (!isValid) {
+      const requiredText = settings.systemMessages?.requiredText || "This field is required";
+      setErrors((prev) => ({
+        ...prev,
+        [field.ref]: requiredText
+      }));
+    }
+    return isValid;
+  }, [currentItem, answers, settings.systemMessages?.requiredText]);
+  const validateCurrent = useCallback(() => {
+    return validateCurrentWithValue();
+  }, [validateCurrentWithValue]);
+  const submit = useCallback(async () => {
+    if (!responseId) return;
+    if (settings.captchaEnabled && !captchaToken) {
+      setShowCaptcha(true);
+      return;
+    }
+    setIsSubmitting(true);
+    try {
+      await client.completeResponse({
+        responseId,
+        sessionId,
+        answers,
+        captchaToken: captchaToken || void 0
+      });
+      setIsCompleted(true);
+      setCurrentIndex(sequence.length - 1);
+      clearProgress(projectId);
+      if (settings.duplicatePrevention) {
+        markAsSubmitted(projectId);
+      }
+      onComplete?.(answers);
+    } catch (error) {
+      onError?.(error);
+    } finally {
+      setIsSubmitting(false);
+      setShowCaptcha(false);
+    }
+  }, [responseId, sessionId, answers, captchaToken, client, sequence.length, projectId, settings.captchaEnabled, settings.duplicatePrevention, onComplete, onError]);
+  const next = useCallback(async (pendingValue) => {
+    if (currentItem?.type === "field") {
+      const isValid = validateCurrentWithValue(pendingValue);
+      if (!isValid) {
+        return;
+      }
+      if (currentIndex === lastFieldIndex) {
+        if (pendingValue !== void 0) {
+          setAnswers((prev) => ({ ...prev, [currentItem.field.ref]: pendingValue }));
+        }
+        await submit();
+        return;
+      }
+      const answersToSave = pendingValue !== void 0 ? { ...answers, [currentItem.field.ref]: pendingValue } : answers;
+      if (responseId) {
+        client.updateAnswers({
+          responseId,
+          sessionId,
+          answers: answersToSave,
+          lastFieldRef: currentItem.field.ref
+        }).catch((error) => {
+          onError?.(error);
+        });
+      }
+    }
+    setCurrentIndex((prev) => Math.min(prev + 1, sequence.length - 1));
+  }, [
+    currentItem,
+    currentIndex,
+    lastFieldIndex,
+    sequence.length,
+    responseId,
+    sessionId,
+    answers,
+    client,
+    onError,
+    validateCurrentWithValue,
+    submit
+  ]);
+  const previous = useCallback(() => {
+    setCurrentIndex((prev) => Math.max(prev - 1, firstFieldIndex));
+  }, [firstFieldIndex]);
+  const goTo = useCallback(
+    (index) => {
+      if (index >= 0 && index < sequence.length) {
+        setCurrentIndex(index);
+      }
+    },
+    [sequence.length]
+  );
+  const setAnswer = useCallback((fieldRef, value) => {
+    setAnswers((prev) => ({ ...prev, [fieldRef]: value }));
+    setErrors((prev) => {
+      const newErrors = { ...prev };
+      delete newErrors[fieldRef];
+      return newErrors;
+    });
+  }, []);
+  const reset = useCallback(() => {
+    setResponseId(null);
+    setCurrentIndex(0);
+    setAnswers(initialAnswers);
+    setErrors({});
+    setIsStarted(false);
+    setIsCompleted(false);
+    setIsSubmitting(false);
+  }, [initialAnswers]);
+  useEffect(() => {
+    if (content.welcomeScreens.length === 0 && !isStarted) {
+      start();
+    }
+  }, [content.welcomeScreens.length, isStarted, start]);
+  return {
+    // State
+    currentIndex,
+    currentItem,
+    answers,
+    errors,
+    isStarted,
+    isCompleted,
+    isSubmitting,
+    responseId,
+    sessionId,
+    isDuplicateSubmission,
+    captchaToken,
+    showCaptcha,
+    // Computed
+    sequence,
+    totalFields,
+    answeredCount,
+    progress,
+    canGoBack,
+    canGoNext,
+    isOnWelcome,
+    isOnThankYou,
+    isOnField,
+    // Actions
+    start,
+    next,
+    previous,
+    goTo,
+    setAnswer,
+    validateCurrent,
+    submit,
+    reset,
+    setCaptchaToken
+  };
+}
+var ThemeContext = createContext(null);
+function useThemeContext() {
+  const theme = useContext(ThemeContext);
+  if (!theme) {
+    throw new Error("useThemeContext must be used within a ThemeProvider");
+  }
+  return theme;
+}
+function useTheme(options) {
+  const { theme, inject = true } = options;
+  const cssVariables = useMemo(() => generateThemeCSS(theme), [theme]);
+  const componentStyles = useMemo(() => generateComponentStyles(), []);
+  useEffect(() => {
+    if (inject && isBrowser()) {
+      const cleanup = injectThemeCSS(theme);
+      return cleanup;
+    }
+  }, [theme, inject]);
+  const backgroundStyle = useMemo(() => {
+    const bg = theme.background;
+    switch (bg.type) {
+      case "gradient":
+        return { background: bg.value };
+      case "image":
+        return {
+          backgroundImage: `url(${bg.value})`,
+          backgroundSize: "cover",
+          backgroundPosition: bg.position || "center"
+        };
+      case "video":
+        return {};
+      default:
+        return {};
+    }
+  }, [theme.background]);
+  return {
+    theme,
+    cssVariables,
+    componentStyles,
+    backgroundStyle
+  };
+}
+function useField(options) {
+  const { field, value, error, onChange, onNext } = options;
+  const isEmpty = value === void 0 || value === "" || Array.isArray(value) && value.length === 0;
+  const onKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey && field.type !== "long_text") {
+        e.preventDefault();
+        onNext?.();
+      }
+    },
+    [field.type, onNext]
+  );
+  const placeholder = useMemo(() => {
+    if ("properties" in field && field.properties) {
+      const props = field.properties;
+      if ("placeholder" in props) {
+        return props.placeholder;
+      }
+    }
+    return void 0;
+  }, [field]);
+  const getInputProps = useCallback(() => {
+    return {
+      value: value || "",
+      onChange: (e) => {
+        onChange(e.target.value);
+      },
+      onKeyDown,
+      placeholder,
+      "aria-invalid": !!error,
+      "aria-describedby": error ? `${field.ref}-error` : void 0
+    };
+  }, [value, onChange, onKeyDown, field.ref, error, placeholder]);
+  const getTextareaProps = useCallback(() => {
+    return {
+      value: value || "",
+      onChange: (e) => {
+        onChange(e.target.value);
+      },
+      placeholder,
+      "aria-invalid": !!error,
+      "aria-describedby": error ? `${field.ref}-error` : void 0
+    };
+  }, [value, onChange, field.ref, error, placeholder]);
+  return {
+    // Field info
+    ref: field.ref,
+    type: field.type,
+    title: field.title,
+    description: field.description,
+    required: field.validations?.required || false,
+    // State
+    value,
+    error,
+    isEmpty,
+    // Handlers
+    onChange,
+    onKeyDown,
+    // Helpers
+    getInputProps,
+    getTextareaProps
+  };
+}
+function useProgress(options) {
+  const { content, answers, currentIndex } = options;
+  return useMemo(() => {
+    const totalFields = content.fields.length;
+    const answeredCount = Object.keys(answers).length;
+    const welcomeCount = content.welcomeScreens.length;
+    const currentFieldIndex = Math.max(0, currentIndex - welcomeCount);
+    const percentage = totalFields > 0 ? answeredCount / totalFields * 100 : 0;
+    const segments = content.fields.map((field, index) => ({
+      index,
+      fieldRef: field.ref,
+      completed: !!answers[field.ref],
+      current: index === currentFieldIndex
+    }));
+    return {
+      totalFields,
+      answeredCount,
+      currentFieldIndex,
+      percentage,
+      segments
+    };
+  }, [content, answers, currentIndex]);
+}
+
+export { ThemeContext, hasCookieConsent, setCookieConsent, useField, useForm, useProgress, useTheme, useThemeContext };
+//# sourceMappingURL=chunk-HUIMGLDC.js.map
+//# sourceMappingURL=chunk-HUIMGLDC.js.map