@nextlyhq/plugin-form-builder 0.0.2-alpha.4 → 0.0.2-alpha.40

package/dist/chunk-WVI7N3QO.js

@@ -0,0 +1,559 @@
+// src/utils/evaluate-conditions.ts
+function isEmptyValue(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return true;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  return false;
+}
+function toNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return NaN;
+    }
+    return Number(trimmed);
+  }
+  return NaN;
+}
+function toString(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.join(", ");
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function compareValues(operator, fieldValue, conditionValue) {
+  switch (operator) {
+    case "equals": {
+      if (Array.isArray(fieldValue)) {
+        if (Array.isArray(conditionValue)) {
+          if (fieldValue.length !== conditionValue.length) {
+            return false;
+          }
+          return fieldValue.every((v, i) => v === conditionValue[i]);
+        }
+        return fieldValue.includes(conditionValue);
+      }
+      return toString(fieldValue) === toString(conditionValue);
+    }
+    case "notEquals": {
+      if (Array.isArray(fieldValue)) {
+        if (Array.isArray(conditionValue)) {
+          if (fieldValue.length !== conditionValue.length) {
+            return true;
+          }
+          return !fieldValue.every((v, i) => v === conditionValue[i]);
+        }
+        return !fieldValue.includes(conditionValue);
+      }
+      return toString(fieldValue) !== toString(conditionValue);
+    }
+    case "contains": {
+      const fieldStr = toString(fieldValue).toLowerCase();
+      const conditionStr = toString(conditionValue).toLowerCase();
+      if (Array.isArray(fieldValue)) {
+        return fieldValue.some(
+          (v) => toString(v).toLowerCase().includes(conditionStr)
+        );
+      }
+      return fieldStr.includes(conditionStr);
+    }
+    case "isEmpty": {
+      return isEmptyValue(fieldValue);
+    }
+    case "isNotEmpty": {
+      return !isEmptyValue(fieldValue);
+    }
+    case "greaterThan": {
+      const fieldNum = toNumber(fieldValue);
+      const conditionNum = toNumber(conditionValue);
+      if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) {
+        return fieldNum > conditionNum;
+      }
+      return toString(fieldValue) > toString(conditionValue);
+    }
+    case "lessThan": {
+      const fieldNum = toNumber(fieldValue);
+      const conditionNum = toNumber(conditionValue);
+      if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) {
+        return fieldNum < conditionNum;
+      }
+      return toString(fieldValue) < toString(conditionValue);
+    }
+    default: {
+      console.warn(
+        `[evaluateConditions] Unknown comparison operator: ${String(operator)}`
+      );
+      return false;
+    }
+  }
+}
+function evaluateSingleCondition(condition, formData) {
+  const { field, comparison, value: conditionValue } = condition;
+  const fieldValue = getNestedValue(formData, field);
+  return compareValues(comparison, fieldValue, conditionValue);
+}
+function getNestedValue(obj, path) {
+  if (!path) {
+    return void 0;
+  }
+  if (!path.includes(".")) {
+    return obj[path];
+  }
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function evaluateConditions(logic, formData) {
+  if (!logic || !logic.enabled) {
+    return true;
+  }
+  const { action, operator, conditions } = logic;
+  if (!conditions || conditions.length === 0) {
+    return true;
+  }
+  const results = conditions.map(
+    (condition) => evaluateSingleCondition(condition, formData)
+  );
+  let conditionsMet;
+  if (operator === "OR") {
+    conditionsMet = results.some((result) => result);
+  } else {
+    conditionsMet = results.every((result) => result);
+  }
+  if (action === "hide") {
+    return !conditionsMet;
+  }
+  return conditionsMet;
+}
+function isValidComparisonOperator(operator) {
+  const validOperators = [
+    "equals",
+    "notEquals",
+    "contains",
+    "isEmpty",
+    "isNotEmpty",
+    "greaterThan",
+    "lessThan"
+  ];
+  return validOperators.includes(operator);
+}
+function getSupportedComparisonOperators() {
+  return [
+    "equals",
+    "notEquals",
+    "contains",
+    "isEmpty",
+    "isNotEmpty",
+    "greaterThan",
+    "lessThan"
+  ];
+}
+
+// src/utils/export-formats.ts
+var UTF8_BOM = "\uFEFF";
+function safeString(value) {
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function formatExportValue(value, field) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (field) {
+    switch (field.type) {
+      case "checkbox":
+        return value ? "Yes" : "No";
+      case "select":
+        if (Array.isArray(value)) {
+          return value.join(", ");
+        }
+        return safeString(value);
+      case "file":
+        if (Array.isArray(value)) {
+          return value.map((v) => safeString(v)).join(", ");
+        }
+        return safeString(value);
+      case "date":
+        if (value instanceof Date) {
+          return value.toISOString().split("T")[0];
+        }
+        if (typeof value === "string") {
+          const parsed = new Date(value);
+          if (!isNaN(parsed.getTime())) {
+            return parsed.toISOString().split("T")[0];
+          }
+        }
+        return safeString(value);
+      case "time":
+        return safeString(value);
+      case "hidden":
+        return safeString(value);
+      default:
+        break;
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.join(", ");
+  }
+  if (typeof value === "boolean") {
+    return value ? "Yes" : "No";
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return safeString(value);
+}
+function formatDate(date, format = "iso") {
+  if (!date) return "";
+  const d = typeof date === "string" ? new Date(date) : date;
+  if (isNaN(d.getTime())) {
+    return "";
+  }
+  return format === "iso" ? d.toISOString() : d.toLocaleString();
+}
+function escapeCSVValue(value, delimiter = ",") {
+  const isFormulaLike = /^[=+\-@\t\r]/.test(value) && !/^-?\d+(\.\d+)?$/.test(value);
+  const escapedFormula = isFormulaLike ? `'${value}` : value;
+  const needsQuoting = escapedFormula.includes(delimiter) || escapedFormula.includes('"') || escapedFormula.includes("\n") || escapedFormula.includes("\r");
+  if (!needsQuoting) {
+    return escapedFormula;
+  }
+  const escaped = escapedFormula.replace(/"/g, '""');
+  return `"${escaped}"`;
+}
+function exportToCSV(submissions, form, options = {}) {
+  const {
+    includeMetadata = true,
+    delimiter = ",",
+    includeBOM = true,
+    dateFormat = "iso"
+  } = options;
+  const exportableFields = form.fields;
+  const headers = [];
+  for (const field of exportableFields) {
+    headers.push(field.label);
+  }
+  if (includeMetadata) {
+    headers.push("ID", "Status", "Submitted At", "IP Address", "User Agent");
+  }
+  const rows = [];
+  for (const submission of submissions) {
+    const row = [];
+    const data = submission.data;
+    for (const field of exportableFields) {
+      const value = data[field.name];
+      const formatted = formatExportValue(value, field);
+      row.push(escapeCSVValue(formatted, delimiter));
+    }
+    if (includeMetadata) {
+      row.push(escapeCSVValue(submission.id, delimiter));
+      row.push(escapeCSVValue(submission.status, delimiter));
+      row.push(
+        escapeCSVValue(
+          formatDate(submission.submittedAt, dateFormat),
+          delimiter
+        )
+      );
+      row.push(escapeCSVValue(submission.ipAddress || "", delimiter));
+      row.push(escapeCSVValue(submission.userAgent || "", delimiter));
+    }
+    rows.push(row);
+  }
+  const escapedHeaders = headers.map((h) => escapeCSVValue(h, delimiter));
+  const lines = [
+    escapedHeaders.join(delimiter),
+    ...rows.map((row) => row.join(delimiter))
+  ];
+  const csvContent = lines.join("\r\n");
+  return includeBOM ? UTF8_BOM + csvContent : csvContent;
+}
+function exportToJSON(submissions, form, options = {}) {
+  const {
+    includeMetadata = true,
+    includeFormDefinition = true,
+    indent = 2
+  } = options;
+  const exportableFields = form.fields;
+  const formDefinition = includeFormDefinition ? {
+    id: form.id,
+    name: form.name,
+    slug: form.slug,
+    fields: exportableFields.map((f) => ({
+      name: f.name,
+      label: f.label,
+      type: f.type
+    }))
+  } : void 0;
+  const exportedSubmissions = submissions.map((submission) => {
+    const data = submission.data;
+    const fieldData = {};
+    for (const field of exportableFields) {
+      const value = data[field.name];
+      fieldData[field.name] = value;
+    }
+    if (includeMetadata) {
+      return {
+        ...fieldData,
+        _metadata: {
+          id: submission.id,
+          status: submission.status,
+          submittedAt: submission.submittedAt,
+          ipAddress: submission.ipAddress || null,
+          userAgent: submission.userAgent || null,
+          createdAt: submission.createdAt,
+          updatedAt: submission.updatedAt
+        }
+      };
+    }
+    return fieldData;
+  });
+  const exportData = {
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalSubmissions: submissions.length,
+    submissions: exportedSubmissions
+  };
+  if (formDefinition) {
+    exportData.form = formDefinition;
+  }
+  return JSON.stringify(exportData, null, indent);
+}
+function downloadFile(content, filename, mimeType) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("downloadFile is only available in browser environments");
+  }
+  const blob = new Blob([content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+function generateExportFilename(formSlug, format) {
+  const safeSlug = formSlug.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "form";
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `${safeSlug}-submissions-${date}.${format}`;
+}
+function exportAndDownload(submissions, form, format, options) {
+  const filename = generateExportFilename(form.slug, format);
+  if (format === "csv") {
+    const content = exportToCSV(submissions, form, options);
+    downloadFile(content, filename, "text/csv;charset=utf-8");
+  } else {
+    const content = exportToJSON(submissions, form, options);
+    downloadFile(content, filename, "application/json");
+  }
+}
+
+// src/types.ts
+var BUILT_IN_FORM_FIELD_TYPES = [
+  "text",
+  "email",
+  "number",
+  "phone",
+  "url",
+  "textarea",
+  "select",
+  "checkbox",
+  "radio",
+  "file",
+  "date",
+  "time",
+  "hidden"
+];
+var BUILT_IN_FORM_FIELD_TYPES_SET = new Set(
+  BUILT_IN_FORM_FIELD_TYPES
+);
+function isKnownFormField(field) {
+  return BUILT_IN_FORM_FIELD_TYPES_SET.has(field.type);
+}
+function isFormField(value) {
+  return typeof value === "object" && value !== null && "type" in value && "name" in value && "label" in value;
+}
+function isFormFieldType(field, type) {
+  return field.type === type;
+}
+function isTextFormField(field) {
+  return field.type === "text";
+}
+function isEmailFormField(field) {
+  return field.type === "email";
+}
+function isSelectFormField(field) {
+  return field.type === "select";
+}
+function isCheckboxFormField(field) {
+  return field.type === "checkbox";
+}
+function isFileFormField(field) {
+  return field.type === "file";
+}
+
+// src/config/defaults.ts
+var DEFAULT_FORM_SETTINGS = {
+  submitButtonText: "Submit",
+  confirmationType: "message",
+  successMessage: "Thank you for your submission!",
+  allowMultipleSubmissions: true
+};
+var DEFAULT_NOTIFICATION_SETTINGS = {
+  enabled: true,
+  replyTo: true
+};
+function toTitleCase(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function pluralize(singular) {
+  if (singular.endsWith("y") && !/[aeiou]y$/i.test(singular)) {
+    return singular.slice(0, -1) + "ies";
+  }
+  if (singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") || singular.endsWith("ch") || singular.endsWith("sh")) {
+    return singular + "es";
+  }
+  return singular + "s";
+}
+function applyFormDefaults(config) {
+  const singularLabel = config.labels?.singular || toTitleCase(config.slug);
+  return {
+    ...config,
+    // Generate labels from slug if not provided
+    labels: {
+      singular: singularLabel,
+      plural: config.labels?.plural || pluralize(singularLabel)
+    },
+    // Apply settings defaults
+    settings: {
+      submitButtonText: config.settings?.submitButtonText || DEFAULT_FORM_SETTINGS.submitButtonText,
+      confirmationType: config.settings?.confirmationType || DEFAULT_FORM_SETTINGS.confirmationType,
+      successMessage: config.settings?.successMessage || DEFAULT_FORM_SETTINGS.successMessage,
+      allowMultipleSubmissions: config.settings?.allowMultipleSubmissions ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
+      // Preserve other settings that don't have defaults
+      redirectUrl: config.settings?.redirectUrl,
+      redirectRelation: config.settings?.redirectRelation,
+      honeypotEnabled: config.settings?.honeypotEnabled,
+      captchaEnabled: config.settings?.captchaEnabled,
+      captchaSiteKey: config.settings?.captchaSiteKey
+    },
+    // Apply notification defaults if notifications are configured
+    notifications: config.notifications ? {
+      enabled: config.notifications.enabled ?? DEFAULT_NOTIFICATION_SETTINGS.enabled,
+      recipients: config.notifications.recipients || [],
+      subject: config.notifications.subject || `New submission for ${singularLabel}`,
+      replyTo: config.notifications.replyTo ?? DEFAULT_NOTIFICATION_SETTINGS.replyTo,
+      template: config.notifications.template
+    } : void 0,
+    // Apply access defaults
+    access: {
+      // Default: anyone can submit the form
+      submit: config.access?.submit || (() => true),
+      // Default: only authenticated users can view submissions
+      read: config.access?.read || (({ req }) => !!req.user)
+    }
+  };
+}
+function applyFieldDefaults(field) {
+  const label = field.label || (field.name ? toTitleCase(field.name.replace(/([A-Z])/g, " $1").trim()) : "");
+  return {
+    ...field,
+    label,
+    required: field.required ?? false
+  };
+}
+function createFormConfig(slug, fields, options) {
+  return applyFormDefaults({
+    slug,
+    fields,
+    ...options
+  });
+}
+
+// src/utils/form-settings.ts
+function asOptionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asOptionalString(value) {
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function normalizeFormSettings(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ...DEFAULT_FORM_SETTINGS };
+  }
+  const source = raw;
+  const legacyMessage = asOptionalString(source.confirmationMessage);
+  const legacyCaptcha = source.captcha && typeof source.captcha === "object" ? source.captcha : void 0;
+  const confirmationType = source.confirmationType === "redirect" || source.confirmationType === "relationship" ? source.confirmationType : "message";
+  return {
+    submitButtonText: asOptionalString(source.submitButtonText) ?? DEFAULT_FORM_SETTINGS.submitButtonText,
+    confirmationType,
+    successMessage: asOptionalString(source.successMessage) ?? legacyMessage ?? DEFAULT_FORM_SETTINGS.successMessage,
+    redirectUrl: asOptionalString(source.redirectUrl),
+    redirectPage: source.redirectPage ?? void 0,
+    redirectRelation: source.redirectRelation && typeof source.redirectRelation === "object" ? source.redirectRelation : void 0,
+    allowMultipleSubmissions: asOptionalBoolean(source.allowMultipleSubmissions) ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
+    honeypotEnabled: asOptionalBoolean(source.honeypotEnabled),
+    captchaEnabled: asOptionalBoolean(source.captchaEnabled) ?? asOptionalBoolean(legacyCaptcha?.enabled),
+    captchaSiteKey: asOptionalString(source.captchaSiteKey) ?? asOptionalString(legacyCaptcha?.siteKey)
+  };
+}
+
+export {
+  evaluateSingleCondition,
+  evaluateConditions,
+  isValidComparisonOperator,
+  getSupportedComparisonOperators,
+  formatExportValue,
+  exportToCSV,
+  exportToJSON,
+  downloadFile,
+  generateExportFilename,
+  exportAndDownload,
+  BUILT_IN_FORM_FIELD_TYPES,
+  isKnownFormField,
+  isFormField,
+  isFormFieldType,
+  isTextFormField,
+  isEmailFormField,
+  isSelectFormField,
+  isCheckboxFormField,
+  isFileFormField,
+  DEFAULT_FORM_SETTINGS,
+  DEFAULT_NOTIFICATION_SETTINGS,
+  toTitleCase,
+  pluralize,
+  applyFormDefaults,
+  applyFieldDefaults,
+  createFormConfig,
+  normalizeFormSettings
+};
+//# sourceMappingURL=chunk-WVI7N3QO.js.map