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

package/lib/components/RJSFPreview/PreviewAsyncDropdown.js

@@ -0,0 +1,111 @@
+import {jsxs,jsx}from'react/jsx-runtime';import {useState,useCallback,useEffect}from'react';const PreviewAsyncDropdown = props => {
+  const {
+    id,
+    placeholder,
+    disabled,
+    readonly,
+    autofocus,
+    options,
+    value,
+    onChange,
+    onBlur,
+    onFocus,
+    uiSchema,
+    multiple = false,
+    schema,
+    required,
+    rawErrors
+  } = props;
+  console.log('we are here', props);
+  const isMultiple = multiple || schema.type === 'array';
+  const [loading, setLoading] = useState(false);
+  const [dropdownOptions, setDropdownOptions] = useState([]);
+  const loadOptions = useCallback(async () => {
+    console.log('loadOptions', uiSchema, schema);
+    const asyncFuncStr = options?.loadOptionsFunc || schema?.loadOptionsFunc;
+    if (!asyncFuncStr) return;
+    console.log('asyncFuncStr', asyncFuncStr);
+    try {
+      setLoading(true);
+      const dummyResults = await new Promise(resolve => {
+        setTimeout(() => {
+          resolve([{
+            label: 'Async Option 1',
+            value: 'async_1'
+          }, {
+            label: 'Async Option 2',
+            value: 'async_2'
+          }, {
+            label: 'Async Option 3',
+            value: 'async_3'
+          }, {
+            label: 'Dynamic Choice A',
+            value: 'dynamic_a'
+          }, {
+            label: 'Dynamic Choice B',
+            value: 'dynamic_b'
+          }]);
+        }, 1000);
+      });
+      setDropdownOptions(dummyResults);
+    } catch (error) {
+      console.error('Error loading async dropdown options:', error);
+    } finally {
+      setLoading(false);
+    }
+  }, [uiSchema, schema]);
+  useEffect(() => {
+    loadOptions();
+  }, [loadOptions]);
+  useEffect(() => {
+    if (options?.enumOptions && !options?.loadOptionsFunc) {
+      const enumOptions = options.enumOptions.map(option => ({
+        label: option.label,
+        value: option.value
+      }));
+      setDropdownOptions(enumOptions);
+    }
+  }, [options, uiSchema]);
+  const handleChange = e => {
+    const selectedValue = e.target.value;
+    onChange(selectedValue);
+  };
+  return jsxs("div", {
+    className: "space-y-3",
+    children: [jsxs("div", {
+      className: "block text-base font-semibold text-gray-800 mb-1",
+      children: [schema?.title, required && jsx("span", {
+        className: "text-red-500 ml-1",
+        children: "*"
+      })]
+    }), jsxs("div", {
+      className: "relative",
+      children: [jsxs("select", {
+        id: id,
+        value: value || '',
+        disabled: disabled || readonly,
+        autoFocus: autofocus,
+        onChange: handleChange,
+        onBlur: onBlur && (() => onBlur(id, value)),
+        onFocus: onFocus && (() => onFocus(id, value)),
+        className: `w-full px-3 pb-2 rounded-md focus:outline-none focus:ring-2 disabled:opacity-50 disabled:cursor-not-allowed text-sm ${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'}`,
+        multiple: isMultiple,
+        children: [jsx("option", {
+          value: "",
+          children: placeholder || 'Select an option...'
+        }), dropdownOptions.map((option, index) => jsx("option", {
+          value: String(option.value),
+          children: String(option.label)
+        }, index))]
+      }), loading && jsx("div", {
+        className: "absolute right-3 top-1/2 transform -translate-y-1/2",
+        children: jsx("div", {
+          className: "animate-spin rounded-full h-4 w-4 border-b-2 border-blue-600"
+        })
+      })]
+    }), rawErrors && rawErrors.length > 0 && jsx("p", {
+      className: "mt-1 text-sm text-red-500",
+      children: rawErrors[0]
+    })]
+  });
+};export{PreviewAsyncDropdown as default};//# sourceMappingURL=PreviewAsyncDropdown.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewAsyncDropdown.js","sources":["../../../src/components/RJSFPreview/PreviewAsyncDropdown.tsx"],"sourcesContent":[null],"names":[],"mappings":"4FAII,MAAA,oBAAmB,GAAA,KAAA,IAAA;AACnB,EAAA,MAAA;AACI,IAAA,EAAA;AACA,IAAA,WAAA;YACF;AACL,IAAA,QAAA;AAOD,IAAA;AA+GA,IAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/RJSFPreview/PreviewCheckboxWidget.js

@@ -0,0 +1,95 @@
+import {jsxs,jsx}from'react/jsx-runtime';const PreviewCheckboxWidget = ({
+  id,
+  value,
+  required,
+  disabled,
+  readonly,
+  onChange,
+  label,
+  placeholder,
+  schema,
+  options,
+  rawErrors
+}) => {
+  const isBooleanCheckbox = schema?.type === 'boolean';
+  const isArrayCheckbox = schema?.type === 'array';
+  if (isBooleanCheckbox) {
+    const handleBooleanChange = event => {
+      onChange(event.target.checked);
+    };
+    const displayLabel = placeholder || schema?.placeholder || label || schema?.title || 'Checkbox';
+    return jsxs("div", {
+      className: "space-y-2",
+      children: [jsxs("div", {
+        className: "flex items-start space-x-3",
+        children: [jsx("input", {
+          id: id,
+          type: "checkbox",
+          checked: value || false,
+          onChange: handleBooleanChange,
+          disabled: disabled || readonly,
+          className: `mt-1 h-4 w-4 text-blue-600 rounded focus:ring-blue-500 focus:ring-2 disabled:opacity-50 disabled:cursor-not-allowed ${rawErrors && rawErrors.length > 0 ? 'border-2 border-red-500' : 'border border-gray-300'}`
+        }), jsx("label", {
+          htmlFor: id,
+          className: `text-sm text-gray-700 ${disabled || readonly ? 'opacity-50 cursor-not-allowed' : 'cursor-pointer'}`,
+          children: displayLabel
+        })]
+      }), rawErrors && rawErrors.length > 0 && jsx("p", {
+        className: "mt-1 text-sm text-red-500",
+        children: rawErrors[0]
+      })]
+    });
+  }
+  if (isArrayCheckbox) {
+    const handleArrayChange = (optionValue, checked) => {
+      const currentValues = Array.isArray(value) ? value : [];
+      let newValues;
+      if (checked) {
+        newValues = currentValues.includes(optionValue) ? currentValues : [...currentValues, optionValue];
+      } else {
+        newValues = currentValues.filter(v => v !== optionValue);
+      }
+      onChange(newValues);
+    };
+    const checkboxOptions = Array.isArray(options?.enumOptions) ? options.enumOptions : Array.isArray(schema?.items?.oneOf) ? (schema?.items?.oneOf || []).map(option => ({
+      value: option.const || option.value || option,
+      label: option.title || option.label || option.const || option
+    })) : Array.isArray(schema?.items?.enum) ? (schema?.items?.enum || []).map(option => ({
+      value: option,
+      label: option
+    })) : [];
+    const currentValues = Array.isArray(value) ? value : [];
+    schema?.title || label || 'Select Options';
+    return jsxs("div", {
+      className: "space-y-2",
+      children: [checkboxOptions.map((option, index) => {
+        const optionValue = option.value !== undefined ? option.value : option;
+        const optionLabel = option.label !== undefined ? option.label : option;
+        const checkboxId = `${id}-${index}`;
+        const isChecked = currentValues.includes(optionValue);
+        return jsxs("div", {
+          className: "flex items-center space-x-3",
+          children: [jsx("input", {
+            id: checkboxId,
+            type: "checkbox",
+            checked: isChecked,
+            onChange: e => handleArrayChange(optionValue, e.target.checked),
+            disabled: disabled || readonly,
+            className: `h-4 w-4 text-blue-600 rounded focus:ring-blue-500 focus:ring-2 disabled:opacity-50 disabled:cursor-not-allowed ${rawErrors && rawErrors.length > 0 ? 'border-2 border-red-500' : 'border border-gray-300'}`
+          }), jsx("label", {
+            htmlFor: checkboxId,
+            className: `text-sm text-gray-700 ${disabled || readonly ? 'opacity-50 cursor-not-allowed' : 'cursor-pointer'}`,
+            children: String(optionLabel)
+          })]
+        }, index);
+      }), rawErrors && rawErrors.length > 0 && jsx("p", {
+        className: "mt-1 text-sm text-red-500",
+        children: rawErrors[0]
+      })]
+    });
+  }
+  return jsxs("div", {
+    className: "text-red-500 text-sm",
+    children: ["Unsupported checkbox schema type: ", schema?.type]
+  });
+};export{PreviewCheckboxWidget};//# sourceMappingURL=PreviewCheckboxWidget.js.map

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

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

package/lib/components/RJSFPreview/PreviewCustomFieldTemplate.js

@@ -0,0 +1,235 @@
+import {jsxs,jsx}from'react/jsx-runtime';import React__default from'react';import {PreviewImageUploadWidget}from'./PreviewImageUploadWidget.js';import {PreviewFileUploadWidget}from'./PreviewFileUploadWidget.js';const PreviewCustomFieldTemplate = props => {
+  const {
+    id,
+    classNames,
+    style,
+    label,
+    help,
+    required,
+    description,
+    errors,
+    children,
+    schema,
+    uiSchema,
+    rawErrors
+  } = props;
+  const isImageField = schema.type === 'string' && schema.format === 'data-url' && (uiSchema?.['ui:widget'] === 'image-upload' || uiSchema?.['ui:options']?.fieldType === 'image' || typeof uiSchema?.['ui:options']?.accept === 'string' && uiSchema['ui:options'].accept.includes('image/*'));
+  const isFileField = schema.type === 'string' && schema.format === 'data-url' && (uiSchema?.['ui:widget'] === 'file-upload' || uiSchema?.['ui:options']?.fieldType === 'file' || typeof uiSchema?.['ui:options']?.accept === 'string' && !uiSchema['ui:options'].accept.includes('image/*'));
+  const isTextareaField = schema.type === 'string' && (uiSchema?.['ui:widget'] === 'textarea' || schema.widget === 'textarea');
+  const isDropdownField = schema.type === 'string' && schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0;
+  const isGroupField = schema.type === 'object' && schema.properties;
+  const isStepField = schema.type === 'object' && schema.properties && (id === 'root' || id === 'root_step1' || id.includes('step'));
+  const isRadioField = schema.type === 'string' && (uiSchema?.['ui:widget'] === 'radio' || uiSchema?.['ui:widget'] === 'MultiFormControl' || schema.widget === 'radio' || schema.oneOf && Array.isArray(schema.oneOf));
+  const shouldShowLabel = label && (isImageField || isFileField || !isStepField && !isGroupField && !isTextareaField && (isDropdownField || schema.type !== 'object'));
+  const isPlainTextOrNumberInput = (schema.type === 'string' || schema.type === 'number') && !isImageField && !isFileField && !isTextareaField && !isDropdownField;
+  if (isPlainTextOrNumberInput) {
+    return jsxs("div", {
+      className: classNames,
+      style: style,
+      children: [React__default.isValidElement(children) ? React__default.cloneElement(children, {
+        rawErrors
+      }) : children, description && id !== 'root' && jsx("p", {
+        className: "text-sm text-gray-600 mb-3",
+        children: description
+      }), help && jsx("p", {
+        className: "text-sm text-gray-500 mt-2",
+        children: help
+      }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+        className: "text-red-600 text-sm mt-2",
+        children: errors.map((error, index) => jsx("div", {
+          children: error
+        }, index))
+      })]
+    });
+  }
+  if (isDropdownField) {
+    return jsxs("div", {
+      className: classNames,
+      style: style,
+      children: [React__default.isValidElement(children) ? React__default.cloneElement(children, {
+        rawErrors
+      }) : children, description && jsx("p", {
+        className: "text-sm text-gray-600 mb-3",
+        children: description
+      }), help && jsx("p", {
+        className: "text-sm text-gray-500 mt-2",
+        children: help
+      }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+        className: "text-red-600 text-sm mt-2",
+        children: errors.map((error, index) => jsx("div", {
+          children: error
+        }, index))
+      })]
+    });
+  }
+  if (isImageField) {
+    const childProps = children?.props;
+    if (childProps) {
+      return jsxs("div", {
+        className: classNames,
+        style: style,
+        children: [shouldShowLabel && jsxs("label", {
+          htmlFor: id,
+          className: "block text-base font-bold text-gray-800 mb-4",
+          children: [label, required && jsx("span", {
+            className: "text-red-500 ml-1",
+            children: "*"
+          })]
+        }), jsx(PreviewImageUploadWidget, {
+          ...childProps
+        }), description && jsx("p", {
+          className: "text-sm text-gray-600 mb-3",
+          children: description
+        }), help && jsx("p", {
+          className: "text-sm text-gray-500 mt-2",
+          children: help
+        }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+          className: "text-red-600 text-sm mt-2",
+          children: errors.map((error, index) => jsx("div", {
+            children: error
+          }, index))
+        })]
+      });
+    }
+  }
+  if (isFileField) {
+    const childProps = children?.props;
+    if (childProps) {
+      return jsxs("div", {
+        className: classNames,
+        style: style,
+        children: [shouldShowLabel && jsxs("label", {
+          htmlFor: id,
+          className: "block text-base font-bold text-gray-800 mb-4",
+          children: [label, required && jsx("span", {
+            className: "text-red-500 ml-1",
+            children: "*"
+          })]
+        }), jsx(PreviewFileUploadWidget, {
+          ...childProps
+        }), description && jsx("p", {
+          className: "text-sm text-gray-600 mb-3",
+          children: description
+        }), help && jsx("p", {
+          className: "text-sm text-gray-500 mt-2",
+          children: help
+        }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+          className: "text-red-600 text-sm mt-2",
+          children: errors.map((error, index) => jsx("div", {
+            children: error
+          }, index))
+        })]
+      });
+    }
+  }
+  if (isTextareaField) {
+    return jsxs("div", {
+      className: classNames,
+      style: style,
+      children: [React__default.isValidElement(children) ? React__default.cloneElement(children, {
+        rawErrors
+      }) : children, help && jsx("p", {
+        className: "text-sm text-gray-500 mt-2",
+        children: help
+      }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+        className: "text-red-600 text-sm mt-2",
+        children: errors.map((error, index) => jsx("div", {
+          children: error
+        }, index))
+      })]
+    });
+  }
+  if (isRadioField) {
+    return jsxs("div", {
+      className: classNames,
+      style: style,
+      children: [React__default.isValidElement(children) ? React__default.cloneElement(children, {
+        rawErrors,
+        label
+      }) : children, description && jsx("p", {
+        className: "text-sm text-gray-600 mb-3",
+        children: description
+      }), help && jsx("p", {
+        className: "text-sm text-gray-500 mt-2",
+        children: help
+      }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+        className: "text-red-600 text-sm mt-2",
+        children: errors.map((error, index) => jsx("div", {
+          children: error
+        }, index))
+      })]
+    });
+  }
+  if (isGroupField && !isStepField) {
+    return jsxs("div", {
+      className: "bg-white rounded-lg pt-5 pr-5 pb-5 pl-0 mb-4",
+      children: [jsx("div", {
+        className: "mb-1",
+        children: React__default.isValidElement(children) ? React__default.cloneElement(children, {
+          rawErrors
+        }) : children
+      }), help && jsx("p", {
+        className: "text-sm text-gray-500 mt-2",
+        children: help
+      }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+        className: "text-red-600 text-sm mt-2",
+        children: errors.map((error, index) => jsx("div", {
+          children: error
+        }, index))
+      })]
+    });
+  }
+  const isBooleanCheckbox = schema.type === 'boolean';
+  const isArrayCheckbox = schema.type === 'array' && !isDropdownField && !isFileField && !isImageField && !isTextareaField;
+  if (isBooleanCheckbox || isArrayCheckbox) {
+    return jsxs("div", {
+      className: "bg-white rounded-lg mb-4",
+      children: [label && jsxs("label", {
+        htmlFor: id,
+        className: "block text-base font-bold text-gray-800 mb-4",
+        children: [label, required && jsx("span", {
+          className: "text-red-500 ml-1",
+          children: "*"
+        })]
+      }), React__default.isValidElement(children) ? React__default.cloneElement(children, {
+        rawErrors
+      }) : children, description && jsx("p", {
+        className: "text-sm text-gray-600 mb-3",
+        children: description
+      }), help && jsx("p", {
+        className: "text-sm text-gray-500 mt-2",
+        children: help
+      }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+        className: "text-red-600 text-sm mt-2",
+        children: errors.map((error, index) => jsx("div", {
+          children: error
+        }, index))
+      })]
+    });
+  }
+  return jsxs("div", {
+    className: classNames,
+    style: style,
+    children: [shouldShowLabel && jsxs("label", {
+      htmlFor: id,
+      className: "block text-base font-bold text-gray-800 mb-4",
+      children: [label, required && jsx("span", {
+        className: "text-red-500 ml-1",
+        children: "*"
+      })]
+    }), React__default.isValidElement(children) ? React__default.cloneElement(children, {
+      rawErrors
+    }) : children, !isTextareaField && description && jsx("p", {
+      className: "text-sm text-gray-600 mb-3",
+      children: description
+    }), help && jsx("p", {
+      className: "text-sm text-gray-500 mt-2",
+      children: help
+    }), errors && Array.isArray(errors) && errors.length > 0 && jsx("div", {
+      className: "text-red-600 text-sm mt-2",
+      children: errors.map((error, index) => jsx("div", {
+        children: error
+      }, index))
+    })]
+  });
+};export{PreviewCustomFieldTemplate};//# sourceMappingURL=PreviewCustomFieldTemplate.js.map

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

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

package/lib/components/RJSFPreview/PreviewDateWidget.js

@@ -0,0 +1,178 @@
+import {jsxs,jsx}from'react/jsx-runtime';import {useState,useRef}from'react';const style = `
+input[type="date"]::-webkit-calendar-picker-indicator {
+  opacity: 0;
+  display: none;
+}
+input[type="date"]::-moz-calendar-picker-indicator {
+  opacity: 0;
+  display: none;
+}
+input[type="date"]::-ms-input-placeholder {
+  opacity: 0;
+  display: none;
+}
+`;
+const PreviewDateWidget = ({
+  id,
+  value,
+  required,
+  disabled,
+  readonly,
+  onChange,
+  placeholder,
+  schema,
+  rawErrors
+}) => {
+  const [isCalendarOpen, setIsCalendarOpen] = useState(false);
+  const [currentDate, setCurrentDate] = useState(() => {
+    if (value) {
+      return new Date(value);
+    }
+    return new Date();
+  });
+  const inputRef = useRef(null);
+  const handleDateChange = event => {
+    const dateValue = event.target.value;
+    onChange(dateValue);
+  };
+  const handleCalendarDateSelect = date => {
+    const formattedDate = date.toISOString().split('T')[0];
+    onChange(formattedDate);
+    setIsCalendarOpen(false);
+  };
+  const generateCalendarDays = () => {
+    const year = currentDate.getFullYear();
+    const month = currentDate.getMonth();
+    const firstDay = new Date(year, month, 1);
+    const startDate = new Date(firstDay);
+    startDate.setDate(startDate.getDate() - firstDay.getDay());
+    const days = [];
+    for (let i = 0; i < 42; i++) {
+      const date = new Date(startDate);
+      date.setDate(startDate.getDate() + i);
+      days.push(date);
+    }
+    return days;
+  };
+  return jsxs("div", {
+    className: "mb-4",
+    children: [jsx("style", {
+      children: style
+    }), 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: "*"
+      })]
+    }), jsxs("div", {
+      className: "relative",
+      children: [jsx("input", {
+        ref: inputRef,
+        id: id,
+        type: "date",
+        value: value || '',
+        onChange: handleDateChange,
+        disabled: disabled || readonly,
+        className: `w-full px-3 py-2 rounded-md focus:outline-none focus:ring-2 disabled:opacity-50 disabled:cursor-not-allowed ${rawErrors && rawErrors.length > 0 ? 'border-2 border-red-500 focus:border-red-500 focus:ring-red-100' : 'border border-gray-300 focus:border-blue-500 focus:ring-blue-500'}`
+      }), rawErrors && rawErrors.length > 0 && jsx("p", {
+        className: "mt-1 text-sm text-red-500",
+        children: rawErrors[0]
+      }), !disabled && !readonly && jsx("button", {
+        type: "button",
+        onClick: () => setIsCalendarOpen(!isCalendarOpen),
+        className: "absolute right-2 top-1/2 transform -translate-y-1/2 text-gray-400 hover:text-gray-600",
+        tabIndex: -1,
+        children: jsx("svg", {
+          className: "w-5 h-5",
+          fill: "none",
+          stroke: "currentColor",
+          viewBox: "0 0 24 24",
+          children: jsx("path", {
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            strokeWidth: 2,
+            d: "M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"
+          })
+        })
+      }), isCalendarOpen && !disabled && !readonly && jsxs("div", {
+        className: "absolute z-10 mt-1 w-64 bg-white border border-gray-300 rounded-md shadow-lg",
+        children: [jsx("div", {
+          className: "p-3 border-b border-gray-200",
+          children: jsxs("div", {
+            className: "flex items-center justify-between",
+            children: [jsx("button", {
+              type: "button",
+              onClick: () => {
+                const prevMonth = new Date(currentDate);
+                prevMonth.setMonth(prevMonth.getMonth() - 1);
+                setCurrentDate(prevMonth);
+              },
+              className: "p-1 hover:bg-gray-100 rounded",
+              children: jsx("svg", {
+                className: "w-4 h-4",
+                fill: "none",
+                stroke: "currentColor",
+                viewBox: "0 0 24 24",
+                children: jsx("path", {
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round",
+                  strokeWidth: 2,
+                  d: "M15 19l-7-7 7-7"
+                })
+              })
+            }), jsx("span", {
+              className: "text-sm font-medium",
+              children: currentDate.toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'long'
+              })
+            }), jsx("button", {
+              type: "button",
+              onClick: () => {
+                const nextMonth = new Date(currentDate);
+                nextMonth.setMonth(nextMonth.getMonth() + 1);
+                setCurrentDate(nextMonth);
+              },
+              className: "p-1 hover:bg-gray-100 rounded",
+              children: jsx("svg", {
+                className: "w-4 h-4",
+                fill: "none",
+                stroke: "currentColor",
+                viewBox: "0 0 24 24",
+                children: jsx("path", {
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round",
+                  strokeWidth: 2,
+                  d: "M9 5l7 7-7 7"
+                })
+              })
+            })]
+          })
+        }), jsxs("div", {
+          className: "p-3",
+          children: [jsx("div", {
+            className: "grid grid-cols-7 gap-1 text-xs text-gray-500 mb-2",
+            children: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].map(day => jsx("div", {
+              className: "text-center",
+              children: day
+            }, day))
+          }), jsx("div", {
+            className: "grid grid-cols-7 gap-1",
+            children: generateCalendarDays().map((date, index) => {
+              const isCurrentMonth = date.getMonth() === currentDate.getMonth();
+              const isToday = date.toDateString() === new Date().toDateString();
+              const isSelected = value && date.toISOString().split('T')[0] === value;
+              return jsx("button", {
+                type: "button",
+                onClick: () => handleCalendarDateSelect(date),
+                className: `p-2 text-sm rounded hover:bg-blue-50 ${!isCurrentMonth ? 'text-gray-300' : 'text-gray-700'} ${isToday ? 'bg-blue-100 font-semibold' : ''} ${isSelected ? 'bg-blue-500 text-white hover:bg-blue-600' : ''}`,
+                children: date.getDate()
+              }, index);
+            })
+          })]
+        })]
+      })]
+    })]
+  });
+};export{PreviewDateWidget};//# sourceMappingURL=PreviewDateWidget.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewDateWidget.js","sources":["../../../src/components/RJSFPreview/PreviewDateWidget.tsx"],"sourcesContent":[null],"names":[],"mappings":"6EAkBA,MAAA,KAAU,GAAA;;AAET;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/RJSFPreview/PreviewDialog.js

@@ -0,0 +1,21 @@
+import {jsx,jsxs}from'react/jsx-runtime';const PreviewDialog = ({
+  open,
+  onClose,
+  children
+}) => {
+  if (!open) return null;
+  return jsx("div", {
+    className: "fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-40",
+    onClick: onClose,
+    children: jsxs("div", {
+      className: "bg-white rounded-lg shadow-lg p-6 min-w-[320px] max-w-lg w-full relative",
+      onClick: e => e.stopPropagation(),
+      children: [jsx("button", {
+        className: "absolute top-2 right-2 text-gray-500 hover:text-gray-700",
+        onClick: onClose,
+        "aria-label": "Close",
+        children: "\u00D7"
+      }), children]
+    })
+  });
+};export{PreviewDialog};//# sourceMappingURL=PreviewDialog.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewDialog.js","sources":["../../../src/components/RJSFPreview/PreviewDialog.tsx"],"sourcesContent":[null],"names":[],"mappings":"yCAEU,MAAA,aAAA,GAAkB,CAAA;MACxB;SACA;AACA,EAAA;AACH,CAAA,KAAA;AAED,EAAA,IAAA,CAAA,IAAA,EAAA,OAAO;;;;;;;;;;;;;;;"}