@admin-layout/tailwind-ui 12.2.4-alpha.98 → 12.2.5-alpha.5

package/lib/components/RJSFPreview/PreviewStepper.js

@@ -0,0 +1,40 @@
+import {jsx,jsxs}from'react/jsx-runtime';const PreviewStepper = ({
+  steps,
+  currentStep,
+  schema
+}) => {
+  steps.indexOf(currentStep);
+  const isSingleStep = steps.length === 1;
+  return jsx("div", {
+    className: "mb-8",
+    children: jsxs("div", {
+      className: "flex items-center justify-center relative",
+      children: [jsx("div", {
+        className: "absolute top-5 left-0 w-full h-0.5 bg-gray-200"
+      }), jsx("div", {
+        className: `flex items-center w-full relative z-10 px-4 ${isSingleStep ? 'justify-center' : 'justify-between'}`,
+        children: steps.map((step, index) => {
+          const isCurrent = currentStep === step;
+          const stepSchema = schema?.properties?.[step];
+          const title = stepSchema?.title || step.replace(/([A-Z])/g, ' $1').replace(/^./, str => str.toUpperCase());
+          return jsxs("div", {
+            className: "flex flex-col items-center",
+            children: [jsx("div", {
+              className: `
+                                        w-10 h-10 rounded-full flex items-center justify-center text-lg font-bold border-2
+                                        ${isCurrent ? 'bg-blue-600 text-white border-white' : 'bg-white text-gray-600 border-gray-300'}
+                                    `,
+              children: index + 1
+            }), jsx("div", {
+              className: "mt-2 text-center",
+              children: jsx("p", {
+                className: `text-sm ${isCurrent ? 'text-blue-600 font-medium' : 'text-gray-600'}`,
+                children: title.replace('_', ' ')
+              })
+            })]
+          }, step);
+        })
+      })]
+    })
+  });
+};export{PreviewStepper};//# sourceMappingURL=PreviewStepper.js.map

package/lib/components/RJSFPreview/PreviewStepper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewStepper.js","sources":["../../../src/components/RJSFPreview/PreviewStepper.tsx"],"sourcesContent":[null],"names":[],"mappings":"yCAEU,MAAA,cAAA,GAAmB,CAAA;OACzB;aACA;;AAEH,CAAA,KAAA;AAED,eAA6B,CAAA,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/RJSFPreview/PreviewSwitchWidget.js

@@ -0,0 +1,75 @@
+import {jsxs,jsx}from'react/jsx-runtime';const PreviewSwitchWidget = ({
+  id,
+  value,
+  required,
+  disabled,
+  readonly,
+  onChange,
+  label,
+  placeholder,
+  options,
+  schema,
+  rawErrors,
+  showTitle = false
+}) => {
+  const handleToggle = () => {
+    if (!disabled && !readonly) {
+      onChange(!value);
+    }
+  };
+  const handleKeyDown = event => {
+    if (event.key === ' ' || event.key === 'Enter') {
+      event.preventDefault();
+      handleToggle();
+    }
+  };
+  return jsxs("div", {
+    className: "space-y-3",
+    children: [showTitle && schema?.title && jsxs("label", {
+      className: "block text-base font-semibold text-gray-800 mb-3",
+      children: [schema.title, required && jsx("span", {
+        className: "text-red-500 ml-1",
+        children: "*"
+      })]
+    }), jsxs("div", {
+      className: "flex items-center space-x-3",
+      children: [jsxs("button", {
+        type: "button",
+        role: "switch",
+        "aria-checked": value || false,
+        "aria-labelledby": `${id}-label`,
+        onClick: handleToggle,
+        onKeyDown: handleKeyDown,
+        disabled: disabled || readonly,
+        className: `
+                        relative inline-flex h-6 w-11 flex-shrink-0 cursor-pointer rounded-full border-2 border-transparent 
+                        transition-colors duration-200 ease-in-out focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2
+                        ${value ? 'bg-blue-600' : 'bg-gray-200'}
+                        ${disabled || readonly ? 'opacity-50 cursor-not-allowed' : 'hover:bg-blue-700 hover:bg-opacity-90'}
+                    `,
+        children: [jsxs("span", {
+          className: "sr-only",
+          children: [value ? 'Disable' : 'Enable', " ", schema?.title || label || 'toggle']
+        }), jsx("span", {
+          "aria-hidden": "true",
+          className: `
+                            pointer-events-none inline-block h-5 w-5 transform rounded-full bg-white shadow ring-0 
+                            transition duration-200 ease-in-out
+                            ${value ? 'translate-x-5' : 'translate-x-0'}
+                        `
+        })]
+      }), jsx("label", {
+        id: `${id}-label`,
+        className: `text-sm text-gray-700 ${disabled || readonly ? 'opacity-50' : 'cursor-pointer'}`,
+        onClick: !disabled && !readonly ? handleToggle : undefined,
+        children: placeholder || options?.placeholder || 'Toggle option'
+      })]
+    }), rawErrors && rawErrors.length > 0 && jsx("p", {
+      className: "text-sm text-red-500 mt-1",
+      children: rawErrors[0]
+    }), schema?.description && jsx("p", {
+      className: "text-xs text-gray-500 mt-1",
+      children: schema.description
+    })]
+  });
+};export{PreviewSwitchWidget};//# sourceMappingURL=PreviewSwitchWidget.js.map

package/lib/components/RJSFPreview/PreviewSwitchWidget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewSwitchWidget.js","sources":["../../../src/components/RJSFPreview/PreviewSwitchWidget.tsx"],"sourcesContent":[null],"names":[],"mappings":"yCACS,MAAA;AAET,EAAA,EAAA;OACI;UACA;AACH,EAAA,QAAA;AAED,EAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/RJSFPreview/PreviewTab.js

@@ -0,0 +1,358 @@
+import {jsx,jsxs}from'react/jsx-runtime';import React__default,{useState,useMemo}from'react';import {PreviewStepper}from'./PreviewStepper.js';import {PreviewFormRenderer}from'./PreviewFormRenderer.js';import {PreviewDialog}from'./PreviewDialog.js';import {generateAmenitiesFragmentSchema}from'./generateSchemaWithInputs.js';const PreviewTab = ({
+  formSchema,
+  uiSchema,
+  customValidateFunction,
+  validator,
+  handleSubmit,
+  isConfigurationSchema = false,
+  extensionData
+}) => {
+  const [currentStep, setCurrentStep] = useState('');
+  const [formData, setFormData] = useState({});
+  const [isLoading, setIsLoading] = useState(false);
+  const [isDialogOpen, setIsDialogOpen] = useState(false);
+  const [submittedData, setSubmittedData] = useState(null);
+  // Get steps from schema
+  const steps = useMemo(() => {
+    if (isConfigurationSchema) {
+      return ['properties'];
+    }
+    return Object.keys(formSchema?.properties || {});
+  }, [formSchema, isConfigurationSchema]);
+  // Set initial step
+  React__default.useEffect(() => {
+    if (steps.length > 0 && !currentStep) {
+      setCurrentStep(steps[0]);
+    }
+  }, [steps, currentStep]);
+  // Get current step schema
+  const currentStepSchema = useMemo(() => {
+    if (isConfigurationSchema) {
+      return {
+        type: 'object',
+        title: '',
+        properties: formSchema?.properties || {},
+        required: formSchema?.required || [],
+        description: formSchema?.description || '',
+        definitions: formSchema?.definitions || formSchema?.$defs || {}
+      };
+    }
+    if (!currentStep || !formSchema?.properties?.[currentStep]) {
+      return null;
+    }
+    const stepSchema = formSchema.properties[currentStep];
+    const stepTitle = stepSchema.title || currentStep;
+    return {
+      type: 'object',
+      title: stepTitle,
+      properties: stepSchema.properties || {},
+      required: stepSchema.required || [],
+      description: stepSchema.description || '',
+      definitions: formSchema.definitions || formSchema.$defs || {}
+    };
+  }, [currentStep, formSchema, isConfigurationSchema]);
+  // Get current step UI schema
+  const currentUISchema = useMemo(() => {
+    if (isConfigurationSchema) {
+      return uiSchema || {};
+    }
+    if (!currentStep || !uiSchema) {
+      return {};
+    }
+    return uiSchema[currentStep] || {};
+  }, [currentStep, uiSchema, isConfigurationSchema]);
+  const handleNext = stepData => {
+    // Save current step data
+    setFormData(prev => ({
+      ...prev,
+      [currentStep]: stepData
+    }));
+    const currentStepIndex = steps.indexOf(currentStep);
+    const isLastStep = currentStepIndex === steps.length - 1;
+    if (isLastStep) {
+      // Instead of submitting, show dialog
+      const allFormData = {
+        ...formData,
+        [currentStep]: stepData
+      };
+      setSubmittedData(allFormData);
+      setIsDialogOpen(true);
+    } else {
+      // Move to next step
+      const nextStep = steps[currentStepIndex + 1];
+      setCurrentStep(nextStep);
+    }
+  };
+  const handlePrevious = () => {
+    const currentStepIndex = steps.indexOf(currentStep);
+    if (currentStepIndex > 0) {
+      const previousStep = steps[currentStepIndex - 1];
+      setCurrentStep(previousStep);
+    }
+  };
+  // Helper to render summary
+  const renderFieldValue = (schema, value) => {
+    if (value === undefined || value === null || value === '') return jsx("span", {
+      className: "text-gray-400",
+      children: "(empty)"
+    });
+    if (typeof value === 'object' && !Array.isArray(value) && value !== null && !(value instanceof Date)) {
+      const properties = schema?.properties || Object.keys(value).reduce((acc, key) => {
+        acc[key] = {};
+        return acc;
+      }, {});
+      return jsx("ul", {
+        className: "pl-4",
+        children: Object.entries(properties).map(([field, fieldSchema]) => jsxs("li", {
+          className: "mb-1",
+          children: [jsxs("span", {
+            className: "font-medium",
+            children: [fieldSchema?.title || field, ":"]
+          }), ' ', renderFieldValue(fieldSchema, value[field])]
+        }, field))
+      });
+    }
+    if (schema?.format === 'data-url' || schema?.type === 'file' || schema?.widget === 'file') {
+      if (typeof value === 'string' && value.startsWith('data:')) {
+        return jsxs("span", {
+          children: [jsx("a", {
+            href: value,
+            download: true,
+            className: "text-blue-600 underline",
+            target: "_blank",
+            rel: "noopener noreferrer",
+            children: "Download file"
+          }), "\u2192 exmaple.com"]
+        });
+      }
+      if (typeof value === 'string') {
+        return jsx("span", {
+          children: value
+        });
+      }
+      return jsx("span", {
+        children: "[file]"
+      });
+    }
+    if (schema?.widget === 'image' || schema?.format === 'image' || typeof value === 'string' && value.startsWith('data:image')) {
+      return jsx("img", {
+        src: value,
+        alt: "Uploaded",
+        className: "max-h-24 max-w-xs rounded border border-gray-200"
+      });
+    }
+    if (typeof value === 'boolean') {
+      return jsx("span", {
+        children: value ? 'Yes' : 'No'
+      });
+    }
+    if (typeof value === 'object' && value !== null && !Array.isArray(value) && 'label' in value && 'value' in value && typeof value.value === 'boolean') {
+      return jsx("span", {
+        children: value.value ? 'Yes' : 'No'
+      });
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0 && value[0] && typeof value[0] === 'object' && 'label' in value[0]) {
+        const displayValues = value.map(item => item.label || item.value || item.key);
+        return jsx("span", {
+          children: displayValues.join(', ')
+        });
+      } else if (schema?.items?.oneOf) {
+        const displayValues = value.map(val => {
+          const option = schema.items.oneOf.find(opt => opt.const === val);
+          return option?.title || val;
+        });
+        return jsx("span", {
+          children: displayValues.join(', ')
+        });
+      }
+      return jsx("span", {
+        children: value.join(', ')
+      });
+    }
+    if (typeof value === 'object' && value !== null && value.label && value.value) {
+      return jsx("span", {
+        children: value.label
+      });
+    }
+    if (typeof value === 'object' && value !== null && value.label && value.key) {
+      return jsxs("span", {
+        children: [value.label, " (key: ", value.key, ")"]
+      });
+    }
+    if (schema?.enum && schema?.enumNames && Array.isArray(schema.enum)) {
+      const idx = schema.enum.indexOf(value);
+      if (idx !== -1 && schema.enumNames[idx]) {
+        return jsx("span", {
+          children: schema.enumNames[idx]
+        });
+      }
+    } else if (schema?.enumLabels && Array.isArray(schema.enumLabels)) {
+      const matchingOption = schema.enumLabels.find(option => option.key === value);
+      if (matchingOption) {
+        return jsx("span", {
+          children: matchingOption.value
+        });
+      }
+    } else if (schema?.enum && Array.isArray(schema.enum)) {
+      const idx = schema.enum.indexOf(value);
+      if (idx !== -1 && schema.enumNames && schema.enumNames[idx]) {
+        return jsx("span", {
+          children: schema.enumNames[idx]
+        });
+      }
+    }
+    return jsx("span", {
+      children: String(value)
+    });
+  };
+  const renderFields = (schema, values, isTopLevel = false) => {
+    if (!schema || !schema.properties || typeof values !== 'object' || values === null) {
+      return null;
+    }
+    return jsx("ul", {
+      className: "pl-4",
+      children: Object.entries(schema.properties).map(([field, fieldSchema]) => {
+        const value = values[field];
+        if (fieldSchema.type === 'object' && fieldSchema.properties) {
+          return jsxs("li", {
+            className: "mb-2",
+            children: [!(isConfigurationSchema && isTopLevel) && jsxs("div", {
+              className: "mb-1",
+              children: [jsxs("span", {
+                className: "font-bold",
+                children: [fieldSchema.title || field, ":"]
+              }), fieldSchema.databaseField && jsxs("span", {
+                className: "text-xs text-gray-500 ml-2",
+                children: ["\u2192 (", fieldSchema.databaseField, ")"]
+              })]
+            }), renderFields(fieldSchema, value, false)]
+          }, field);
+        }
+        const isObjectValue = typeof value === 'object' && !Array.isArray(value) && value !== null && !(value instanceof Date);
+        return jsxs("li", {
+          className: "mb-1",
+          children: [jsxs("span", {
+            className: "font-medium",
+            children: [fieldSchema.title || field, ":"]
+          }), isObjectValue && fieldSchema.databaseField && jsxs("span", {
+            className: "text-xs text-gray-500 ml-2",
+            children: ["\u2192 (", fieldSchema.databaseField, ")"]
+          }), ' ', renderFieldValue(fieldSchema, value), !isObjectValue && fieldSchema.databaseField && jsxs("span", {
+            className: "text-xs text-gray-500 ml-2",
+            children: ["\u2192 (", fieldSchema.databaseField, ")"]
+          })]
+        }, field);
+      })
+    });
+  };
+  const renderSummary = data => {
+    if (isConfigurationSchema) {
+      const actualFormData = data.properties || data;
+      return jsx("div", {
+        className: "space-y-6",
+        children: jsx("div", {
+          className: "bg-gray-50 border border-gray-200 rounded-lg p-4 mb-2",
+          children: renderFields(formSchema, actualFormData, true)
+        })
+      });
+    }
+    return jsx("div", {
+      className: "space-y-6",
+      children: Object.entries(data).map(([step, values]) => {
+        const stepSchema = formSchema?.properties?.[step];
+        return jsxs("div", {
+          className: "bg-gray-50 border border-gray-200 rounded-lg p-4 mb-2",
+          children: [!(stepSchema && stepSchema.type === 'object' && stepSchema.properties) && jsx("div", {
+            className: "font-semibold text-lg mb-2 text-gray-800 border-b border-gray-200 pb-1",
+            children: stepSchema?.title || step
+          }), renderFields(stepSchema, values, false)]
+        }, step);
+      })
+    });
+  };
+  if (!currentStepSchema) {
+    return jsx("main", {
+      className: "flex-1 p-8 overflow-y-auto",
+      children: jsx("div", {
+        className: "max-w-4xl mx-auto",
+        children: jsx("div", {
+          className: "text-center text-gray-500",
+          children: "No form steps available"
+        })
+      })
+    });
+  }
+  return jsx("main", {
+    className: "flex-1 p-8 overflow-y-auto",
+    children: jsxs("div", {
+      className: "max-w-4xl mx-auto",
+      children: [!isConfigurationSchema && jsx(PreviewStepper, {
+        steps: steps,
+        currentStep: currentStep,
+        schema: formSchema
+      }), jsxs("div", {
+        className: "bg-white border border-gray-200 rounded-lg shadow-sm p-5 mb-8",
+        children: [jsx("h2", {
+          className: "text-3xl font-bold text-gray-800 text-center",
+          children: isConfigurationSchema ? formSchema?.properties?.configurationStep?.title || 'Configuration' : currentStepSchema?.title || currentStep
+        }), !isConfigurationSchema && currentStepSchema?.description && jsx("div", {
+          className: "text-lg text-gray-800 font-medium text-center mb-2 mt-2",
+          children: currentStepSchema.description
+        }), jsx(PreviewFormRenderer, {
+          schema: currentStepSchema,
+          uiSchema: currentUISchema,
+          stepName: currentStep,
+          onNext: handleNext,
+          onPrevious: steps.indexOf(currentStep) > 0 ? handlePrevious : undefined,
+          isLoading: isLoading,
+          isLastStep: steps.indexOf(currentStep) === steps.length - 1,
+          customValidateFunction: customValidateFunction,
+          validator: validator
+        })]
+      }), jsxs(PreviewDialog, {
+        open: isDialogOpen,
+        onClose: () => setIsDialogOpen(false),
+        children: [jsx("h3", {
+          className: "text-xl font-bold mb-4 text-center",
+          children: "Review Your Submission"
+        }), jsx("div", {
+          className: "max-h-[60vh] overflow-y-auto pr-2",
+          children: submittedData ? renderSummary(submittedData) : jsx("div", {
+            className: "text-center text-gray-500 py-8",
+            children: "No data to review"
+          })
+        }), jsxs("div", {
+          className: "flex justify-end gap-2 mt-6",
+          children: [jsx("button", {
+            className: "px-4 py-2 bg-gray-200 rounded hover:bg-gray-300",
+            onClick: () => setIsDialogOpen(false),
+            children: "Cancel"
+          }), jsx("button", {
+            className: "px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700",
+            onClick: () => {
+              setIsDialogOpen(false);
+              setIsLoading(true);
+              if (isConfigurationSchema && submittedData) {
+                const amenitiesFragmentSchema = generateAmenitiesFragmentSchema(formSchema);
+                console.log('amenitiesFragmentSchema', {
+                  amenitiesFragmentSchema
+                });
+                handleSubmit({
+                  formData: submittedData,
+                  amenitiesFragmentSchema
+                });
+              } else {
+                handleSubmit({
+                  formData: submittedData
+                });
+              }
+              setIsLoading(false);
+            },
+            children: "Confirm & Submit"
+          })]
+        })]
+      })]
+    })
+  });
+};export{PreviewTab};//# sourceMappingURL=PreviewTab.js.map

package/lib/components/RJSFPreview/PreviewTab.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewTab.js","sources":["../../../src/components/RJSFPreview/PreviewTab.tsx"],"sourcesContent":[null],"names":[],"mappings":"oUAWI,MAAA,UACI,GAAA,CAAA;YAIA;UACA;wBACA;AACH,EAAA;cACD;uBACmB,GAAC,KAAA;AACvB,EAAA;AAED,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/RJSFPreview/PreviewTextareaWidget.js

@@ -0,0 +1,45 @@
+import {jsxs,jsx}from'react/jsx-runtime';const PreviewTextareaWidget = ({
+  id,
+  value,
+  required,
+  disabled,
+  readonly,
+  onChange,
+  placeholder,
+  schema,
+  rawErrors
+}) => {
+  const handleChange = event => {
+    const textValue = event.target.value;
+    if (typeof onChange === 'function') {
+      onChange(textValue);
+    }
+  };
+  return jsxs("div", {
+    className: "bg-white  rounded-lg mb-4 space-y-2",
+    children: [schema?.title && jsxs("label", {
+      htmlFor: id,
+      className: "block text-base font-semibold text-gray-800 mb-3",
+      children: [schema.title, required && jsx("span", {
+        className: "text-red-500 ml-1",
+        children: "*"
+      })]
+    }), jsx("textarea", {
+      id: id,
+      value: value || '',
+      onChange: handleChange,
+      disabled: disabled || readonly,
+      placeholder: placeholder,
+      rows: 4,
+      minLength: schema?.minLength,
+      maxLength: schema?.maxLength,
+      className: `w-full px-3 py-2 rounded-md shadow-sm focus:outline-none focus:ring-2 disabled:opacity-50 disabled:cursor-not-allowed resize-vertical min-h-[100px] ${rawErrors && rawErrors.length > 0 ? 'border-2 border-red-500 focus:border-red-500 focus:ring-red-500' : 'border border-gray-300 focus:border-blue-500 focus:ring-blue-500'}`
+    }), schema?.maxLength && jsxs("div", {
+      className: "text-xs text-gray-500 text-right mt-1",
+      children: [(value || '').length, "/", schema.maxLength, " characters"]
+    }), rawErrors && rawErrors.length > 0 && jsx("p", {
+      className: "mt-1 text-sm text-red-500",
+      children: rawErrors[0]
+    })]
+  });
+};export{PreviewTextareaWidget};//# sourceMappingURL=PreviewTextareaWidget.js.map

package/lib/components/RJSFPreview/PreviewTextareaWidget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewTextareaWidget.js","sources":["../../../src/components/RJSFPreview/PreviewTextareaWidget.tsx"],"sourcesContent":[null],"names":[],"mappings":"yCACS,MAAA;AAET,EAAA,EAAA;OACI;AACH,EAAA,QAAA;AAED,EAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/RJSFPreview/generateSchemaWithInputs.js

@@ -0,0 +1,134 @@
+/**
+ * Generates a JSON schema with input values embedded in the properties
+ */
+function generateSchemaWithInputs(formSchema, formData) {
+  if (!formSchema || !formData) {
+    return formSchema;
+  }
+  const newSchema = JSON.parse(JSON.stringify(formSchema));
+  function processProperties(schema, data) {
+    if (!schema || !schema.properties) {
+      return {};
+    }
+    const result = {};
+    for (const [propertyName, propertySchema] of Object.entries(schema.properties)) {
+      const inputValue = data?.[propertyName];
+      const safePropertySchema = propertySchema && typeof propertySchema === 'object' ? propertySchema : {};
+      if (safePropertySchema && typeof safePropertySchema === 'object' && safePropertySchema['type'] === 'object' && safePropertySchema['properties'] && typeof safePropertySchema['properties'] === 'object') {
+        const nestedValues = processProperties(safePropertySchema, inputValue);
+        result[propertyName] = nestedValues;
+      } else {
+        if (safePropertySchema && safePropertySchema['type'] === 'boolean' && typeof inputValue === 'boolean') {
+          const fieldLabel = safePropertySchema['placeholder'] || safePropertySchema['title'] || propertyName;
+          result[propertyName] = {
+            label: fieldLabel,
+            value: inputValue
+          };
+        } else if (safePropertySchema && safePropertySchema['type'] === 'array' && safePropertySchema['items'] && safePropertySchema['items']['oneOf'] && Array.isArray(inputValue)) {
+          const oneOfOptions = safePropertySchema['items']['oneOf'];
+          const selectedObjects = inputValue.map(selectedKey => {
+            const option = oneOfOptions.find(opt => opt.const === selectedKey);
+            return {
+              label: option?.title || selectedKey,
+              value: selectedKey
+            };
+          });
+          result[propertyName] = selectedObjects;
+        } else {
+          if (inputValue !== undefined && inputValue !== null && inputValue !== '') {
+            result[propertyName] = inputValue;
+          } else {
+            result[propertyName] = null;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  return processProperties(newSchema, formData);
+}
+function extractConfigurationFormData(formData) {
+  return formData;
+}
+function extractMultiStepFormData(formData) {
+  const flattenedData = {};
+  for (const [, stepData] of Object.entries(formData)) {
+    if (typeof stepData === 'object' && stepData !== null) {
+      Object.assign(flattenedData, stepData);
+    }
+  }
+  return flattenedData;
+}
+function generateAmenitiesFragmentSchema(formSchema) {
+  if (!formSchema) {
+    return null;
+  }
+  const definitions = formSchema.definitions || formSchema.$defs || {};
+  const transformedDefs = {};
+  function removeTitle(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map(removeTitle);
+    } else if (obj && typeof obj === 'object') {
+      const {
+        title,
+        ...rest
+      } = obj;
+      const result = {};
+      for (const [key, value] of Object.entries(rest)) {
+        result[key] = removeTitle(value);
+      }
+      return result;
+    }
+    return obj;
+  }
+  for (const [defName, defSchema] of Object.entries(definitions)) {
+    transformedDefs[defName] = removeTitle(defSchema);
+  }
+  function transformProperties(properties) {
+    if (!properties || typeof properties !== 'object') {
+      return {};
+    }
+    const transformedProps = {};
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const schema = propSchema;
+      if (schema.type === 'object' && schema.properties) {
+        transformedProps[propName] = {
+          type: 'object',
+          properties: transformProperties(schema.properties)
+        };
+      } else if (schema.$ref) {
+        let normalizedRef = schema.$ref;
+        if (normalizedRef.startsWith('#/definitions/')) {
+          normalizedRef = normalizedRef.replace('#/definitions/', '#/$defs/');
+        }
+        transformedProps[propName] = {
+          $ref: normalizedRef
+        };
+      } else {
+        const fieldType = schema.type || 'string';
+        const baseDefName = `${propName}Base`;
+        if (!transformedDefs[baseDefName]) {
+          transformedDefs[baseDefName] = {
+            type: fieldType
+          };
+        }
+        transformedProps[propName] = {
+          $ref: `#/$defs/${baseDefName}`
+        };
+      }
+    }
+    return transformedProps;
+  }
+  const transformedProperties = transformProperties(formSchema.properties);
+  const schemaWithoutTitle = removeTitle({
+    type: 'object',
+    properties: transformedProperties
+  });
+  const amenitiesFragment = {
+    configuration: {
+      $defs: transformedDefs,
+      schema: schemaWithoutTitle
+    }
+  };
+  return amenitiesFragment;
+}export{extractConfigurationFormData,extractMultiStepFormData,generateAmenitiesFragmentSchema,generateSchemaWithInputs};//# sourceMappingURL=generateSchemaWithInputs.js.map

package/lib/components/RJSFPreview/generateSchemaWithInputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSchemaWithInputs.js","sources":["../../../src/components/RJSFPreview/generateSchemaWithInputs.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;AAEG;AACH,SAAA,wBAAgB,CAAA,UAAyB,EAAA,QAAY,EAAA;AA4DrD,EAAA,IAAA,CAAA,UAAA,IAAA,CAAA;AAIA,IAAA,OAAA,UAAA;AAUA,EAAA;AAwFA,EAAA,MAAA,SAAA,GAAA,IAAgB,gCAAgC,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}