@dmitryvim/form-builder 0.2.5 → 0.2.6

package/dist/cjs/index.cjs

@@ -62,9 +62,6 @@ function validateSchema(schema) {
     errors.push("Schema must be an object");
     return errors;
   }
-  if (!schema.version) {
-    errors.push("Schema missing version");
-  }
   if (!Array.isArray(schema.elements)) {
     errors.push("Schema missing elements array");
     return errors;
@@ -78,6 +75,20 @@ function validateSchema(schema) {
       if (!element.key) {
         errors.push(`${elementPath}: missing key`);
       }
+      if (element.displayIf) {
+        const displayIf = element.displayIf;
+        if (!displayIf.key || typeof displayIf.key !== "string") {
+          errors.push(
+            `${elementPath}: displayIf must have a 'key' property of type string`
+          );
+        }
+        const hasOperator = "equals" in displayIf;
+        if (!hasOperator) {
+          errors.push(
+            `${elementPath}: displayIf must have at least one operator (equals, etc.)`
+          );
+        }
+      }
       if (element.type === "group" && "elements" in element && element.elements) {
         validateElements(element.elements, `${elementPath}.elements`);
       }
@@ -115,6 +126,66 @@ function clear(node) {
   while (node.firstChild) node.removeChild(node.firstChild);
 }
 
+// src/utils/display-conditions.ts
+function getValueByPath(data, path) {
+  if (!data || typeof data !== "object") {
+    return void 0;
+  }
+  const segments = path.match(/[^.[\]]+|\[\d+\]/g);
+  if (!segments || segments.length === 0) {
+    return void 0;
+  }
+  let current = data;
+  for (const segment of segments) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      const index = parseInt(segment.slice(1, -1), 10);
+      if (!Array.isArray(current) || isNaN(index)) {
+        return void 0;
+      }
+      current = current[index];
+    } else {
+      current = current[segment];
+    }
+  }
+  return current;
+}
+function evaluateDisplayCondition(condition, formData) {
+  if (!condition || !condition.key) {
+    throw new Error(
+      "Invalid displayIf condition: must have a 'key' property"
+    );
+  }
+  const actualValue = getValueByPath(formData, condition.key);
+  if ("equals" in condition) {
+    return deepEqual(actualValue, condition.equals);
+  }
+  throw new Error(
+    `Invalid displayIf condition: no recognized operator (equals, etc.)`
+  );
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === "object" && typeof b === "object") {
+    try {
+      return JSON.stringify(a) === JSON.stringify(b);
+    } catch (e) {
+      if (e instanceof TypeError && (e.message.includes("circular") || e.message.includes("cyclic"))) {
+        console.warn(
+          "deepEqual: Circular reference detected in displayIf comparison, using reference equality"
+        );
+        return a === b;
+      }
+      throw e;
+    }
+  }
+  return a === b;
+}
+
 // src/components/text.ts
 function renderTextElement(element, ctx, wrapper, pathKey) {
   const state = ctx.state;
@@ -2249,7 +2320,7 @@ function renderElement(element, ctx) {
   return renderElementFunc(element, ctx);
 }
 function renderSingleContainerElement(element, ctx, wrapper, pathKey) {
-  var _a;
+  var _a, _b;
   const containerWrap = document.createElement("div");
   containerWrap.className = "border border-gray-200 rounded-lg p-4 bg-gray-50";
   containerWrap.setAttribute("data-container", pathKey);
@@ -2264,6 +2335,9 @@ function renderSingleContainerElement(element, ctx, wrapper, pathKey) {
   const subCtx = {
     path: pathJoin(ctx.path, element.key),
     prefill: ((_a = ctx.prefill) == null ? void 0 : _a[element.key]) || {},
+    // Sliced data for value population
+    formData: (_b = ctx.formData) != null ? _b : ctx.prefill,
+    // Complete root data for displayIf evaluation
     state: ctx.state
   };
   element.elements.forEach((child) => {
@@ -2276,7 +2350,7 @@ function renderSingleContainerElement(element, ctx, wrapper, pathKey) {
   wrapper.appendChild(containerWrap);
 }
 function renderMultipleContainerElement(element, ctx, wrapper, _pathKey) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const state = ctx.state;
   const containerWrap = document.createElement("div");
   containerWrap.className = "border border-gray-200 rounded-lg p-4 bg-gray-50";
@@ -2303,12 +2377,15 @@ function renderMultipleContainerElement(element, ctx, wrapper, _pathKey) {
     add.className = "px-3 py-1.5 bg-blue-600 text-white text-sm rounded-lg hover:bg-blue-700 transition-colors";
     add.textContent = t("addElement", state);
     add.onclick = () => {
+      var _a2;
       if (countItems() < max) {
         const idx = countItems();
         const subCtx = {
           state: ctx.state,
           path: pathJoin(ctx.path, `${element.key}[${idx}]`),
-          prefill: {}
+          prefill: {},
+          formData: (_a2 = ctx.formData) != null ? _a2 : ctx.prefill
+          // Complete root data for displayIf
         };
         const item = document.createElement("div");
         item.className = "containerItem border border-gray-300 rounded-lg p-4 bg-white";
@@ -2350,10 +2427,13 @@ function renderMultipleContainerElement(element, ctx, wrapper, _pathKey) {
   }
   if (pre && Array.isArray(pre)) {
     pre.forEach((prefillObj, idx) => {
+      var _a2;
       const subCtx = {
         state: ctx.state,
         path: pathJoin(ctx.path, `${element.key}[${idx}]`),
-        prefill: prefillObj || {}
+        prefill: prefillObj || {},
+        formData: (_a2 = ctx.formData) != null ? _a2 : ctx.prefill
+        // Complete root data for displayIf
       };
       const item = document.createElement("div");
       item.className = "containerItem border border-gray-300 rounded-lg p-4 bg-white";
@@ -2384,7 +2464,9 @@ function renderMultipleContainerElement(element, ctx, wrapper, _pathKey) {
       const subCtx = {
         state: ctx.state,
         path: pathJoin(ctx.path, `${element.key}[${idx}]`),
-        prefill: {}
+        prefill: {},
+        formData: (_d = ctx.formData) != null ? _d : ctx.prefill
+        // Complete root data for displayIf
       };
       const item = document.createElement("div");
       item.className = "containerItem border border-gray-300 rounded-lg p-4 bg-white";
@@ -2668,8 +2750,32 @@ if (typeof document !== "undefined") {
   });
 }
 function renderElement2(element, ctx) {
+  var _a;
+  if (element.displayIf) {
+    try {
+      const dataForCondition = (_a = ctx.formData) != null ? _a : ctx.prefill;
+      const shouldDisplay = evaluateDisplayCondition(
+        element.displayIf,
+        dataForCondition
+      );
+      if (!shouldDisplay) {
+        const hiddenWrapper = document.createElement("div");
+        hiddenWrapper.className = "fb-field-wrapper-hidden";
+        hiddenWrapper.style.display = "none";
+        hiddenWrapper.setAttribute("data-field-key", element.key);
+        hiddenWrapper.setAttribute("data-conditionally-hidden", "true");
+        return hiddenWrapper;
+      }
+    } catch (error) {
+      console.error(
+        `Error evaluating displayIf for field "${element.key}":`,
+        error
+      );
+    }
+  }
   const wrapper = document.createElement("div");
   wrapper.className = "mb-6 fb-field-wrapper";
+  wrapper.setAttribute("data-field-key", element.key);
   const label = document.createElement("div");
   label.className = "flex items-center mb-2";
   const title = document.createElement("label");
@@ -3162,6 +3268,7 @@ var FormBuilderInstance = class {
     }
     this.state.debounceTimer = setTimeout(() => {
       const formData = this.validateForm(true);
+      this.reevaluateConditionalFields();
       if (this.state.config.onChange) {
         this.state.config.onChange(formData);
       }
@@ -3421,6 +3528,8 @@ var FormBuilderInstance = class {
       const block = renderElement2(element, {
         path: "",
         prefill: prefill || {},
+        formData: prefill || {},
+        // Pass complete root data for displayIf evaluation
         state: this.state,
         instance: this
       });
@@ -3465,6 +3574,19 @@ var FormBuilderInstance = class {
     };
     setValidateElement(validateElement2);
     this.state.schema.elements.forEach((element) => {
+      if (element.displayIf) {
+        try {
+          const shouldDisplay = evaluateDisplayCondition(element.displayIf, data);
+          if (!shouldDisplay) {
+            return;
+          }
+        } catch (error) {
+          console.error(
+            `Error evaluating displayIf for field "${element.key}" during validation:`,
+            error
+          );
+        }
+      }
       if (element.hidden) {
         data[element.key] = element.default !== void 0 ? element.default : null;
       } else {
@@ -3621,6 +3743,71 @@ var FormBuilderInstance = class {
       );
     }
   }
+  /**
+   * Re-evaluate all conditional fields (displayIf) based on current form data
+   * This is called automatically when form data changes (via onChange events)
+   */
+  reevaluateConditionalFields() {
+    if (!this.state.schema || !this.state.formRoot) return;
+    const formData = this.validateForm(true).data;
+    const checkElements = (elements, currentPath) => {
+      elements.forEach((element) => {
+        const fullPath = currentPath ? `${currentPath}.${element.key}` : element.key;
+        if (element.displayIf) {
+          const fieldWrappers = this.state.formRoot.querySelectorAll(
+            `[data-field-key="${element.key}"]`
+          );
+          fieldWrappers.forEach((wrapper) => {
+            var _a, _b;
+            try {
+              const shouldDisplay = evaluateDisplayCondition(
+                element.displayIf,
+                formData
+                // Use complete formData for condition evaluation
+              );
+              const isCurrentlyHidden = wrapper.getAttribute("data-conditionally-hidden") === "true";
+              if (shouldDisplay && isCurrentlyHidden) {
+                const newWrapper = renderElement2(element, {
+                  path: fullPath,
+                  // Use accumulated path
+                  prefill: formData,
+                  // Use complete formData for root-level elements
+                  formData,
+                  // Pass complete formData for displayIf evaluation
+                  state: this.state,
+                  instance: this
+                });
+                (_a = wrapper.parentNode) == null ? void 0 : _a.replaceChild(newWrapper, wrapper);
+              } else if (!shouldDisplay && !isCurrentlyHidden) {
+                const hiddenWrapper = document.createElement("div");
+                hiddenWrapper.className = "fb-field-wrapper-hidden";
+                hiddenWrapper.style.display = "none";
+                hiddenWrapper.setAttribute("data-field-key", element.key);
+                hiddenWrapper.setAttribute("data-conditionally-hidden", "true");
+                (_b = wrapper.parentNode) == null ? void 0 : _b.replaceChild(hiddenWrapper, wrapper);
+              }
+            } catch (error) {
+              console.error(
+                `Error re-evaluating displayIf for field "${element.key}":`,
+                error
+              );
+            }
+          });
+        }
+        if ((element.type === "container" || element.type === "group") && "elements" in element && element.elements) {
+          const containerData = formData == null ? void 0 : formData[element.key];
+          if (Array.isArray(containerData)) {
+            containerData.forEach((_, index) => {
+              checkElements(element.elements, `${fullPath}[${index}]`);
+            });
+          } else {
+            checkElements(element.elements, fullPath);
+          }
+        }
+      });
+    };
+    checkElements(this.state.schema.elements, "");
+  }
   /**
    * Destroy instance and clean up resources
    */