@rjsf/daisyui 6.0.0-beta.2

package/dist/index.js

@@ -0,0 +1,2180 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Form: () => DaisyUIForm_default,
+  GridTemplate: () => GridTemplate,
+  Templates: () => Templates_default,
+  Theme: () => Theme_default,
+  ThemeProvider: () => ThemeProvider,
+  Widgets: () => Widgets_default,
+  __createDaisyUIFrameProvider: () => __createDaisyUIFrameProvider,
+  default: () => index_default,
+  useTheme: () => useTheme
+});
+module.exports = __toCommonJS(index_exports);
+var import_core4 = require("@rjsf/core");
+
+// src/theme/Theme.tsx
+var import_react19 = require("react");
+var import_core2 = require("@rjsf/core");
+
+// src/templates/ArrayFieldItemButtonsTemplate/ArrayFieldItemButtonsTemplate.tsx
+var import_react = require("react");
+var import_utils = require("@rjsf/utils");
+var import_jsx_runtime = require("react/jsx-runtime");
+function ArrayFieldItemButtonsTemplate(props) {
+  const {
+    disabled,
+    hasCopy,
+    hasMoveDown,
+    hasMoveUp,
+    hasRemove,
+    idSchema,
+    index,
+    onCopyIndexClick,
+    onDropIndexClick,
+    onReorderClick,
+    readonly,
+    registry,
+    uiSchema
+  } = props;
+  const { CopyButton: CopyButton2, MoveDownButton: MoveDownButton2, MoveUpButton: MoveUpButton2, RemoveButton: RemoveButton2 } = registry.templates.ButtonTemplates;
+  const onCopyClick = (0, import_react.useMemo)(() => onCopyIndexClick(index), [index, onCopyIndexClick]);
+  const onRemoveClick = (0, import_react.useMemo)(() => onDropIndexClick(index), [index, onDropIndexClick]);
+  const onArrowUpClick = (0, import_react.useMemo)(() => onReorderClick(index, index - 1), [index, onReorderClick]);
+  const onArrowDownClick = (0, import_react.useMemo)(() => onReorderClick(index, index + 1), [index, onReorderClick]);
+  const renderMany = [hasMoveUp || hasMoveDown, hasCopy, hasRemove].filter(Boolean).length > 1;
+  const btnClass = renderMany ? "join-item btn btn-sm px-2" : "btn btn-sm px-2 rounded-sm";
+  const removeBtnClass = renderMany ? "join-item btn btn-sm btn-error px-2" : "btn btn-sm btn-error px-2 rounded-sm";
+  const buttons = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    (hasMoveUp || hasMoveDown) && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        MoveUpButton2,
+        {
+          id: (0, import_utils.buttonId)(idSchema, "moveUp"),
+          className: `rjsf-array-item-move-up ${btnClass}`,
+          disabled: disabled || readonly || !hasMoveUp,
+          onClick: onArrowUpClick,
+          uiSchema,
+          registry
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        MoveDownButton2,
+        {
+          id: (0, import_utils.buttonId)(idSchema, "moveDown"),
+          className: `rjsf-array-item-move-down ${btnClass}`,
+          disabled: disabled || readonly || !hasMoveDown,
+          onClick: onArrowDownClick,
+          uiSchema,
+          registry
+        }
+      )
+    ] }),
+    hasCopy && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      CopyButton2,
+      {
+        id: (0, import_utils.buttonId)(idSchema, "copy"),
+        className: `rjsf-array-item-copy ${btnClass}`,
+        disabled: disabled || readonly,
+        onClick: onCopyClick,
+        uiSchema,
+        registry
+      }
+    ),
+    hasRemove && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      RemoveButton2,
+      {
+        id: (0, import_utils.buttonId)(idSchema, "remove"),
+        className: `rjsf-array-item-remove ${removeBtnClass}`,
+        disabled: disabled || readonly,
+        onClick: onRemoveClick,
+        uiSchema,
+        registry
+      }
+    )
+  ] });
+  return renderMany ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "join", children: buttons }) : buttons;
+}
+
+// src/templates/ArrayFieldItemTemplate/ArrayFieldItemTemplate.tsx
+var import_utils2 = require("@rjsf/utils");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function ArrayFieldItemTemplate(props) {
+  const { children, buttonsProps, hasToolbar, registry, uiSchema, index, totalItems } = props;
+  const uiOptions = (0, import_utils2.getUiOptions)(uiSchema);
+  const ArrayFieldItemButtonsTemplate2 = (0, import_utils2.getTemplate)(
+    "ArrayFieldItemButtonsTemplate",
+    registry,
+    uiOptions
+  );
+  const isFirstItem = index === 0;
+  const isLastItem = index === totalItems - 1;
+  const borderRadius = isFirstItem ? "rounded-t-lg" : isLastItem ? "rounded-b-lg" : "";
+  const marginBottom = isLastItem ? "" : "mb-[-1px]";
+  const zIndex = index === void 0 ? "" : "z-" + (10 - Math.min(index, 9));
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("fieldset", { className: `fieldset bg-base-100 border border-base-300 p-4 ${borderRadius} ${marginBottom} ${zIndex}`, children: [
+    children,
+    hasToolbar && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flex justify-end mt-2", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ArrayFieldItemButtonsTemplate2, { ...buttonsProps }) })
+  ] });
+}
+
+// src/templates/ArrayFieldTemplate/ArrayFieldTemplate.tsx
+var import_react2 = require("react");
+var import_utils3 = require("@rjsf/utils");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function ArrayFieldTemplate(props) {
+  const {
+    canAdd,
+    className,
+    disabled,
+    idSchema,
+    items,
+    onAddClick,
+    readonly,
+    registry,
+    required,
+    schema,
+    title,
+    uiSchema
+  } = props;
+  const uiOptions = (0, import_utils3.getUiOptions)(uiSchema);
+  const ArrayFieldDescriptionTemplate = (0, import_utils3.getTemplate)(
+    "ArrayFieldDescriptionTemplate",
+    registry,
+    uiOptions
+  );
+  const ArrayFieldItemTemplate2 = (0, import_utils3.getTemplate)(
+    "ArrayFieldItemTemplate",
+    registry,
+    uiOptions
+  );
+  const ArrayFieldTitleTemplate = (0, import_utils3.getTemplate)(
+    "ArrayFieldTitleTemplate",
+    registry,
+    uiOptions
+  );
+  const {
+    ButtonTemplates: { AddButton: AddButton2 }
+  } = registry.templates;
+  const handleAddClick = (0, import_react2.useCallback)(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      onAddClick(e);
+    },
+    [onAddClick]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `array-field-template ${className}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      ArrayFieldTitleTemplate,
+      {
+        idSchema,
+        title: uiOptions.title || title,
+        schema,
+        uiSchema,
+        required,
+        registry
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      ArrayFieldDescriptionTemplate,
+      {
+        idSchema,
+        description: uiOptions.description || schema.description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "flex flex-col gap-4", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "rjsf-array-item-list", children: [
+        items && items.map(({ key, ...itemProps }, index) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ArrayFieldItemTemplate2, { ...itemProps, index, totalItems: items.length }, key)),
+        items && items.length === 0 && canAdd && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "text-center italic text-base-content/70", children: import_utils3.TranslatableString.EmptyArray })
+      ] }),
+      canAdd && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "flex justify-end", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        AddButton2,
+        {
+          id: (0, import_utils3.buttonId)(idSchema, "add"),
+          className: "rjsf-array-item-add btn btn-primary btn-sm",
+          onClick: handleAddClick,
+          disabled: disabled || readonly,
+          uiSchema,
+          registry
+        }
+      ) })
+    ] })
+  ] });
+}
+
+// src/templates/BaseInputTemplate/BaseInputTemplate.tsx
+var import_react3 = require("react");
+var import_utils4 = require("@rjsf/utils");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function BaseInputTemplate(props) {
+  const {
+    id,
+    value,
+    required,
+    disabled,
+    readonly,
+    autofocus,
+    onChange,
+    onBlur,
+    onFocus,
+    onChangeOverride,
+    options,
+    schema,
+    type,
+    label,
+    placeholder
+  } = props;
+  const inputProps = (0, import_utils4.getInputProps)(schema, type, options);
+  const { step, min, max, accept, ...rest } = inputProps;
+  const htmlInputProps = { step, min, max, accept, ...schema.examples ? { list: (0, import_utils4.examplesId)(id) } : void 0 };
+  const _onChange = (0, import_react3.useCallback)(
+    ({ target: { value: value2 } }) => onChange(value2 === "" ? options.emptyValue : value2),
+    [onChange, options]
+  );
+  const _onBlur = (0, import_react3.useCallback)(
+    ({ target }) => onBlur && onBlur(id, target.value),
+    [onBlur, id]
+  );
+  const _onFocus = (0, import_react3.useCallback)(
+    ({ target }) => onFocus && onFocus(id, target.value),
+    [onFocus, id]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "form-control", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("label", { htmlFor: id, className: "label hidden", style: { display: "none" }, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { className: "label-text", children: label }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        "input",
+        {
+          id,
+          name: id,
+          value: value || value === 0 ? value : "",
+          placeholder,
+          required,
+          disabled: disabled || readonly,
+          autoFocus: autofocus,
+          className: "input input-bordered",
+          ...rest,
+          ...htmlInputProps,
+          onChange: onChangeOverride || _onChange,
+          onBlur: _onBlur,
+          onFocus: _onFocus,
+          "aria-describedby": (0, import_utils4.ariaDescribedByIds)(id, !!schema.examples)
+        }
+      )
+    ] }),
+    Array.isArray(schema.examples) && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("datalist", { id: (0, import_utils4.examplesId)(id), children: schema.examples.concat(schema.default && !schema.examples.includes(schema.default) ? [schema.default] : []).map((example) => {
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("option", { value: example }, example);
+    }) })
+  ] });
+}
+
+// src/templates/ButtonTemplates/AddButton.tsx
+var import_utils5 = require("@rjsf/utils");
+var import_fontawesome_svg_core = require("@fortawesome/fontawesome-svg-core");
+var import_free_solid_svg_icons = require("@fortawesome/free-solid-svg-icons");
+
+// src/templates/ButtonTemplates/DaisyUIButton.tsx
+var import_react4 = require("react");
+var import_react_fontawesome = require("@fortawesome/react-fontawesome");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function DaisyUIButton(props) {
+  const { icon, iconType, uiSchema, registry, className, ...otherProps } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("button", { type: "button", className, "aria-label": props.title, ...otherProps, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_fontawesome.FontAwesomeIcon, { icon, className: "h-5 w-5" }) });
+}
+DaisyUIButton.displayName = "DaisyUIButton";
+var DaisyUIButton_default = (0, import_react4.memo)(DaisyUIButton);
+
+// src/templates/ButtonTemplates/AddButton.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+import_fontawesome_svg_core.library.add(import_free_solid_svg_icons.faPlus, import_free_solid_svg_icons.faCopy, import_free_solid_svg_icons.faArrowDown, import_free_solid_svg_icons.faArrowUp, import_free_solid_svg_icons.faTrash);
+function AddButton({
+  className,
+  onClick,
+  disabled,
+  registry,
+  ...otherProps
+}) {
+  const { translateString } = registry;
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "row", children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("p", { className: `col-xs-3 col-xs-offset-9 text-right ${className}`, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    DaisyUIButton_default,
+    {
+      ...otherProps,
+      iconType: "info",
+      icon: import_free_solid_svg_icons.faPlus,
+      className: "btn-add col-xs-12 btn-primary btn-primary-content",
+      title: translateString(import_utils5.TranslatableString.AddButton),
+      onClick,
+      disabled,
+      registry
+    }
+  ) }) });
+}
+
+// src/templates/ButtonTemplates/SubmitButton.tsx
+var import_utils6 = require("@rjsf/utils");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+function SubmitButton({ uiSchema }) {
+  const { submitText, norender, props: submitButtonProps = {} } = (0, import_utils6.getSubmitButtonOptions)(uiSchema);
+  if (norender) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    "button",
+    {
+      type: "submit",
+      ...submitButtonProps,
+      className: `btn btn-primary btn-primary-content ${submitButtonProps.className || ""}`,
+      children: submitText
+    }
+  ) });
+}
+
+// src/templates/ButtonTemplates/IconButton.tsx
+var import_utils7 = require("@rjsf/utils");
+var import_free_solid_svg_icons2 = require("@fortawesome/free-solid-svg-icons");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function CopyButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(DaisyUIButton_default, { ...props, title: translateString(import_utils7.TranslatableString.CopyButton), icon: import_free_solid_svg_icons2.faCopy });
+}
+function MoveDownButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    DaisyUIButton_default,
+    {
+      ...props,
+      title: translateString(import_utils7.TranslatableString.MoveDownButton),
+      icon: import_free_solid_svg_icons2.faArrowDown
+    }
+  );
+}
+function MoveUpButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    DaisyUIButton_default,
+    {
+      ...props,
+      title: translateString(import_utils7.TranslatableString.MoveUpButton),
+      icon: import_free_solid_svg_icons2.faArrowUp
+    }
+  );
+}
+function RemoveButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    DaisyUIButton_default,
+    {
+      ...props,
+      title: translateString(import_utils7.TranslatableString.RemoveButton),
+      iconType: "danger",
+      icon: import_free_solid_svg_icons2.faTrash
+    }
+  );
+}
+
+// src/templates/DescriptionField/DescriptionField.tsx
+var import_core = require("@rjsf/core");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function DescriptionField(props) {
+  const { id, description, registry, uiSchema } = props;
+  if (!description) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { id, className: "description-field my-4", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { className: "text-sm text-base-content/80", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_core.RichDescription, { description, registry, uiSchema }) }) });
+}
+
+// src/templates/ErrorList/ErrorList.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+function ErrorList(props) {
+  const { errors } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "error-list", children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("ul", { className: "list-disc list-inside text-red-600", children: errors.map((error, index) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("li", { children: error.stack }, index)) }) });
+}
+
+// src/templates/FieldErrorTemplate/FieldErrorTemplate.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function FieldErrorTemplate(props) {
+  const { errors } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { className: "rjsf-field-error-template text-red-600", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("ul", { className: "list-disc list-inside", children: errors?.map((error, index) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("li", { children: error }, index)) ?? [] }) });
+}
+
+// src/templates/FieldHelpTemplate/FieldHelpTemplate.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+function FieldHelpTemplate(props) {
+  const { help } = props;
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: "rjsf-field-help-template text-gray-500 text-sm", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { children: help }) });
+}
+
+// src/templates/FieldTemplate/FieldTemplate.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function FieldTemplate(props) {
+  const {
+    id,
+    label,
+    children,
+    errors,
+    formContext,
+    formData,
+    help,
+    hideError,
+    displayLabel,
+    classNames,
+    // Destructure props we don't want to pass to div
+    onKeyChange,
+    onDropPropertyClick,
+    uiSchema,
+    schema,
+    readonly,
+    required,
+    rawErrors,
+    rawHelp,
+    rawDescription,
+    hidden,
+    onChange,
+    registry,
+    ...divProps
+  } = props;
+  const isCheckbox = schema.type === "boolean";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: `field-template mb-3 ${classNames || ""}`, ...divProps, children: [
+    displayLabel && !isCheckbox && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("label", { htmlFor: id, className: "label", children: /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("span", { className: "label-text font-medium", children: [
+      label,
+      required && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("span", { className: "text-error ml-1", children: "*" })
+    ] }) }),
+    children,
+    errors,
+    help
+  ] });
+}
+
+// src/templates/GridTemplate/GridTemplate.tsx
+var import_jsx_runtime14 = require("react/jsx-runtime");
+function GridTemplate(props) {
+  const { children, column, ...rest } = props;
+  if (column) {
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { className: "flex-grow", ...rest, children });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { className: "flex flex-wrap gap-4", ...rest, children });
+}
+
+// src/templates/ObjectFieldTemplate/ObjectFieldTemplate.tsx
+var import_utils8 = require("@rjsf/utils");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function ObjectFieldTemplate(props) {
+  const {
+    description,
+    title,
+    properties,
+    required,
+    disabled,
+    readonly,
+    uiSchema,
+    idSchema,
+    schema,
+    formData,
+    onAddClick,
+    registry
+  } = props;
+  const uiOptions = (0, import_utils8.getUiOptions)(uiSchema);
+  const TitleFieldTemplate = (0, import_utils8.getTemplate)("TitleFieldTemplate", registry, uiOptions);
+  const DescriptionFieldTemplate = (0, import_utils8.getTemplate)(
+    "DescriptionFieldTemplate",
+    registry,
+    uiOptions
+  );
+  const {
+    ButtonTemplates: { AddButton: AddButton2 }
+  } = registry.templates;
+  const isRoot = idSchema.$id === "root";
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: `form-control ${isRoot ? "bg-base-100 p-6 rounded-xl shadow-lg" : ""}`, children: [
+    title && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      TitleFieldTemplate,
+      {
+        id: (0, import_utils8.titleId)(idSchema),
+        title,
+        required,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    description && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      DescriptionFieldTemplate,
+      {
+        id: (0, import_utils8.descriptionId)(idSchema),
+        description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: `grid grid-cols-1 gap-${description ? 3 : 4} ${isRoot ? "" : "mb-4"}`, children: [
+      properties.map(
+        (element, index) => element.hidden ? element.content : /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          "div",
+          {
+            className: idSchema.$id === "root" && element.name === "tasks" ? "mt-2" : "",
+            children: element.content
+          },
+          `${idSchema.$id}-${element.name}-${index}`
+        )
+      ),
+      (0, import_utils8.canExpand)(schema, uiSchema, formData) && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "flex justify-end", children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        AddButton2,
+        {
+          id: (0, import_utils8.buttonId)(idSchema, "add"),
+          className: "rjsf-object-property-expand btn btn-primary btn-sm",
+          onClick: onAddClick(schema),
+          disabled: disabled || readonly,
+          uiSchema,
+          registry
+        }
+      ) })
+    ] })
+  ] });
+}
+
+// src/templates/TitleField/TitleField.tsx
+var import_utils9 = require("@rjsf/utils");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+function TitleField(props) {
+  const { id, title, uiSchema } = props;
+  const uiOptions = (0, import_utils9.getUiOptions)(uiSchema);
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { id, className: "title-field mb-6", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("h2", { className: "text-3xl font-bold text-primary mb-2", children: uiOptions.title || title }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "divider divider-primary" })
+  ] });
+}
+
+// src/templates/WrapIfAdditionalTemplate/WrapIfAdditionalTemplate.tsx
+var import_react5 = require("react");
+var import_utils10 = require("@rjsf/utils");
+var import_jsx_runtime17 = require("react/jsx-runtime");
+function WrapIfAdditionalTemplate(props) {
+  const {
+    children,
+    classNames,
+    disabled,
+    id,
+    label,
+    readonly,
+    required,
+    schema,
+    onKeyChange,
+    onDropPropertyClick,
+    registry,
+    ...rest
+  } = props;
+  const { translateString } = registry;
+  const handleBlur = (0, import_react5.useCallback)(
+    (event) => {
+      onKeyChange(event.target.value);
+    },
+    [onKeyChange]
+  );
+  const handleRemove = (0, import_react5.useCallback)(() => {
+    onDropPropertyClick(label)();
+  }, [onDropPropertyClick, label]);
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: `wrap-if-additional-template ${classNames}`, ...rest, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "flex items-center", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "input",
+        {
+          type: "text",
+          className: "input input-bordered",
+          id: `${id}-key`,
+          onBlur: handleBlur,
+          defaultValue: label,
+          disabled: disabled || readonly
+        }
+      ),
+      schema.additionalProperties && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        "button",
+        {
+          id: (0, import_utils10.buttonId)(id, "remove"),
+          className: "rjsf-array-item-remove btn btn-danger ml-2",
+          onClick: handleRemove,
+          disabled: disabled || readonly,
+          children: translateString(import_utils10.TranslatableString.RemoveButton)
+        }
+      )
+    ] }),
+    children
+  ] });
+}
+
+// src/templates/Templates.tsx
+function generateTemplates() {
+  return {
+    ArrayFieldItemTemplate,
+    ArrayFieldTemplate,
+    ArrayFieldItemButtonsTemplate,
+    BaseInputTemplate,
+    ButtonTemplates: {
+      AddButton,
+      SubmitButton,
+      CopyButton,
+      MoveDownButton,
+      MoveUpButton,
+      RemoveButton
+    },
+    DescriptionFieldTemplate: DescriptionField,
+    ErrorListTemplate: ErrorList,
+    FieldErrorTemplate,
+    FieldHelpTemplate,
+    FieldTemplate,
+    GridTemplate,
+    ObjectFieldTemplate,
+    TitleFieldTemplate: TitleField,
+    WrapIfAdditionalTemplate
+  };
+}
+var Templates_default = generateTemplates();
+
+// src/widgets/AltDateTimeWidget/AltDateTimeWidget.tsx
+var import_jsx_runtime18 = require("react/jsx-runtime");
+function AltDateTimeWidget({
+  time = true,
+  ...props
+}) {
+  const { AltDateWidget: AltDateWidget2 } = props.registry.widgets;
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(AltDateWidget2, { time, ...props });
+}
+var AltDateTimeWidget_default = AltDateTimeWidget;
+
+// src/widgets/AltDateWidget/AltDateWidget.tsx
+var import_react6 = require("react");
+var import_utils11 = require("@rjsf/utils");
+var import_jsx_runtime19 = require("react/jsx-runtime");
+function readyForChange(state, time = false) {
+  return state.year && state.month && state.day && (!time || state.hour && state.minute && state.second);
+}
+function getDateElementProps(state, time, yearsRange, format3 = "YMD") {
+  const rangeOptions = yearsRange ?? [1900, (/* @__PURE__ */ new Date()).getFullYear() + 2];
+  const formats = {
+    YMD: ["year", "month", "day"],
+    MDY: ["month", "day", "year"],
+    DMY: ["day", "month", "year"]
+  };
+  const dateElements = formats[format3].map((key) => ({
+    type: key,
+    value: state[key],
+    range: key === "year" ? rangeOptions : key === "month" ? [1, 12] : key === "day" ? [1, 31] : [0, 59]
+  }));
+  if (time) {
+    dateElements.push(
+      { type: "hour", value: state.hour, range: [0, 23] },
+      { type: "minute", value: state.minute, range: [0, 59] },
+      { type: "second", value: state.second, range: [0, 59] }
+    );
+  }
+  return dateElements;
+}
+function DateElement({
+  type,
+  range,
+  value,
+  select,
+  rootId,
+  name,
+  disabled,
+  readonly,
+  autofocus,
+  registry,
+  onBlur,
+  onFocus
+}) {
+  const id = `${rootId}_${type}`;
+  const { SelectWidget: SelectWidget2 } = registry.widgets;
+  const handleChange = (0, import_react6.useCallback)(
+    (value2) => {
+      select(type, value2);
+    },
+    [select, type]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+    SelectWidget2,
+    {
+      schema: { type: "integer" },
+      id,
+      name,
+      className: "select select-bordered select-sm w-full",
+      options: { enumOptions: (0, import_utils11.dateRangeOptions)(range[0], range[1]) },
+      placeholder: type,
+      value,
+      disabled,
+      readonly,
+      autofocus,
+      onChange: handleChange,
+      onBlur,
+      onFocus,
+      registry,
+      label: "",
+      "aria-describedby": (0, import_utils11.ariaDescribedByIds)(rootId),
+      required: false
+    }
+  );
+}
+function convertToRJSFDateObject(dateObj) {
+  return {
+    year: dateObj.year ? parseInt(dateObj.year) : 0,
+    month: dateObj.month ? parseInt(dateObj.month) : 0,
+    day: dateObj.day ? parseInt(dateObj.day) : 0,
+    hour: dateObj.hour ? parseInt(dateObj.hour) : 0,
+    minute: dateObj.minute ? parseInt(dateObj.minute) : 0,
+    second: dateObj.second ? parseInt(dateObj.second) : 0
+  };
+}
+function AltDateWidget({
+  time = false,
+  disabled = false,
+  readonly = false,
+  autofocus = false,
+  options = {},
+  id,
+  name,
+  registry,
+  onBlur,
+  onFocus,
+  onChange,
+  value
+}) {
+  const { translateString } = registry;
+  const [lastValue, setLastValue] = (0, import_react6.useState)(value);
+  const initialState = (0, import_utils11.parseDateString)(value, time);
+  const dateReducer = (state2, action) => {
+    return { ...state2, ...action };
+  };
+  const [state, setState] = (0, import_react6.useReducer)(dateReducer, initialState);
+  (0, import_react6.useEffect)(() => {
+    const rjsfDateObj = convertToRJSFDateObject(state);
+    const stateValue = (0, import_utils11.toDateString)(rjsfDateObj, time);
+    if (readyForChange(state, time) && stateValue !== value) {
+      onChange(stateValue);
+    } else if (lastValue !== value) {
+      setLastValue(value);
+      setState((0, import_utils11.parseDateString)(value, time));
+    }
+  }, [time, value, onChange, state, lastValue]);
+  const handleChange = (0, import_react6.useCallback)((property, value2) => {
+    setState({ [property]: value2 });
+  }, []);
+  const handleSetNow = (0, import_react6.useCallback)(
+    (event) => {
+      event.preventDefault();
+      if (disabled || readonly) {
+        return;
+      }
+      const nextState = (0, import_utils11.parseDateString)((/* @__PURE__ */ new Date()).toJSON(), time);
+      const rjsfDateObj = convertToRJSFDateObject(nextState);
+      onChange((0, import_utils11.toDateString)(rjsfDateObj, time));
+    },
+    [disabled, readonly, time, onChange]
+  );
+  const handleClear = (0, import_react6.useCallback)(
+    (event) => {
+      event.preventDefault();
+      if (disabled || readonly) {
+        return;
+      }
+      onChange(void 0);
+    },
+    [disabled, readonly, onChange]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "space-y-3", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("div", { className: "grid grid-cols-3 gap-2", children: getDateElementProps(
+      state,
+      time,
+      options.yearsRange,
+      options.format
+    ).map((elemProps, i) => /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "form-control", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("label", { className: "label", children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "label-text capitalize", children: elemProps.type }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+        DateElement,
+        {
+          rootId: id,
+          name,
+          select: handleChange,
+          type: elemProps.type,
+          range: elemProps.range,
+          value: elemProps.value,
+          disabled,
+          readonly,
+          registry,
+          onBlur,
+          onFocus,
+          autofocus: autofocus && i === 0
+        }
+      )
+    ] }, i)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("div", { className: "flex justify-start space-x-2", children: [
+      (options.hideNowButton !== void 0 ? !options.hideNowButton : true) && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+        "button",
+        {
+          type: "button",
+          className: "btn btn-sm btn-primary",
+          onClick: handleSetNow,
+          disabled: disabled || readonly,
+          children: translateString(import_utils11.TranslatableString.NowLabel)
+        }
+      ),
+      (options.hideClearButton !== void 0 ? !options.hideClearButton : true) && /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+        "button",
+        {
+          type: "button",
+          className: "btn btn-sm btn-secondary",
+          onClick: handleClear,
+          disabled: disabled || readonly,
+          children: translateString(import_utils11.TranslatableString.ClearLabel)
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/widgets/CheckboxWidget/CheckboxWidget.tsx
+var import_react7 = require("react");
+var import_utils12 = require("@rjsf/utils");
+var import_jsx_runtime20 = require("react/jsx-runtime");
+function CheckboxWidget(props) {
+  const {
+    id,
+    value,
+    required,
+    disabled,
+    hideLabel,
+    label,
+    readonly,
+    registry,
+    options,
+    schema,
+    uiSchema,
+    onChange,
+    onFocus,
+    onBlur
+  } = props;
+  const DescriptionFieldTemplate = (0, import_utils12.getTemplate)(
+    "DescriptionFieldTemplate",
+    registry,
+    options
+  );
+  const description = options.description || schema.description;
+  const handleFocus = (0, import_react7.useCallback)(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [onFocus, id, value]);
+  const handleBlur = (0, import_react7.useCallback)(() => {
+    if (onBlur) {
+      onBlur(id, value);
+    }
+  }, [onBlur, id, value]);
+  const handleChange = (0, import_react7.useCallback)(
+    (event) => {
+      onChange(event.target.checked);
+    },
+    [onChange]
+  );
+  const input = /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+    "input",
+    {
+      type: "checkbox",
+      id,
+      checked: value,
+      required,
+      disabled: disabled || readonly,
+      onChange: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      className: "checkbox"
+    }
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("div", { className: "form-control", children: [
+    !hideLabel && description && /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+      DescriptionFieldTemplate,
+      {
+        id: (0, import_utils12.descriptionId)(id),
+        description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    hideLabel || !label ? input : /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("label", { className: "label cursor-pointer justify-start", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("div", { className: "mr-2", children: input }),
+      /* @__PURE__ */ (0, import_jsx_runtime20.jsxs)("span", { className: "label-text", children: [
+        label,
+        required && /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { className: "text-error ml-1", children: "*" })
+      ] })
+    ] })
+  ] });
+}
+
+// src/widgets/CheckboxesWidget/CheckboxesWidget.tsx
+var import_react8 = require("react");
+var import_jsx_runtime21 = require("react/jsx-runtime");
+function CheckboxesWidget({
+  id,
+  disabled,
+  options,
+  value,
+  readonly,
+  required,
+  onChange,
+  onFocus,
+  onBlur
+}) {
+  const { enumOptions } = options;
+  const isEnumeratedObject = enumOptions && enumOptions[0]?.value && typeof enumOptions[0].value === "object";
+  const isChecked = (0, import_react8.useCallback)(
+    (option) => {
+      if (!Array.isArray(value)) {
+        return false;
+      }
+      if (isEnumeratedObject) {
+        return value.some((v) => v.name === option.value.name);
+      }
+      return value.includes(option.value);
+    },
+    [value, isEnumeratedObject]
+  );
+  const handleChange = (0, import_react8.useCallback)(
+    (event) => {
+      const index = Number(event.target.dataset.index);
+      const option = enumOptions?.[index];
+      if (!option) {
+        return;
+      }
+      const newValue = Array.isArray(value) ? [...value] : [];
+      const optionValue = isEnumeratedObject ? option.value : option.value;
+      if (isChecked(option)) {
+        onChange(newValue.filter((v) => isEnumeratedObject ? v.name !== optionValue.name : v !== optionValue));
+      } else {
+        onChange([...newValue, optionValue]);
+      }
+    },
+    [onChange, value, isChecked, isEnumeratedObject, enumOptions]
+  );
+  const handleFocus = (0, import_react8.useCallback)(
+    (event) => {
+      if (onFocus) {
+        const index = Number(event.target.dataset.index);
+        const option = enumOptions?.[index];
+        if (option) {
+          onFocus(id, option.value);
+        }
+      }
+    },
+    [onFocus, id, enumOptions]
+  );
+  const handleBlur = (0, import_react8.useCallback)(
+    (event) => {
+      if (onBlur) {
+        const index = Number(event.target.dataset.index);
+        const option = enumOptions?.[index];
+        if (option) {
+          onBlur(id, option.value);
+        }
+      }
+    },
+    [onBlur, id, enumOptions]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: "form-control", children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { className: "flex flex-col gap-2 mt-1", children: enumOptions?.map((option, index) => /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("label", { className: "flex items-center cursor-pointer gap-2", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      "input",
+      {
+        type: "checkbox",
+        id: `${id}-${option.value}`,
+        className: "checkbox",
+        name: id,
+        checked: isChecked(option),
+        required,
+        disabled: disabled || readonly,
+        "data-index": index,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("span", { className: "label-text", children: option.label })
+  ] }, option.value)) }) });
+}
+
+// src/widgets/DateTimeWidget/DateTimeWidget.tsx
+var import_react9 = require("react");
+var import_free_solid_svg_icons3 = require("@fortawesome/free-solid-svg-icons");
+var import_react_fontawesome2 = require("@fortawesome/react-fontawesome");
+var import_date_fns = require("date-fns");
+var import_react_day_picker = require("react-day-picker");
+var import_style = require("react-day-picker/dist/style.css");
+var import_jsx_runtime22 = require("react/jsx-runtime");
+function useDatePickerState(initialDate) {
+  const [isOpen, setIsOpen] = (0, import_react9.useState)(false);
+  const [month, setMonth] = (0, import_react9.useState)(initialDate ?? /* @__PURE__ */ new Date());
+  return { isOpen, setIsOpen, month, setMonth };
+}
+function useClickOutside(ref, callback) {
+  (0, import_react9.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        callback();
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [ref, callback]);
+}
+var dayPickerStyles = {
+  classNames: {
+    [import_react_day_picker.UI.Root]: "relative",
+    [import_react_day_picker.UI.Nav]: "hidden",
+    [import_react_day_picker.UI.Chevron]: "hidden",
+    [import_react_day_picker.UI.CaptionLabel]: "hidden",
+    [import_react_day_picker.UI.Dropdowns]: "flex justify-between gap-4 px-4 pb-4",
+    [import_react_day_picker.UI.Dropdown]: "select select-bordered select-sm w-32",
+    [import_react_day_picker.UI.MonthsDropdown]: "select select-bordered select-sm",
+    [import_react_day_picker.UI.YearsDropdown]: "select select-bordered select-sm",
+    [import_react_day_picker.UI.Months]: "flex justify-center",
+    [import_react_day_picker.UI.Month]: "w-full",
+    [import_react_day_picker.UI.MonthCaption]: "flex justify-center",
+    [import_react_day_picker.UI.MonthGrid]: "w-full",
+    [import_react_day_picker.UI.Weekdays]: "grid grid-cols-7 text-center border-b mb-2 pb-1 text-base-content/60 uppercase",
+    [import_react_day_picker.UI.Weekday]: "p-1 font-medium text-base-content/60 text-sm",
+    [import_react_day_picker.UI.Week]: "grid grid-cols-7",
+    [import_react_day_picker.UI.Day]: "w-10 h-8 p-0 relative rounded-md",
+    [import_react_day_picker.UI.DayButton]: "btn btn-ghost absolute inset-0 flex items-center justify-center w-full h-full cursor-pointer rounded-md hover:btn-primary"
+  },
+  modifiers: {
+    selected: "btn btn-accent min-h-0 h-full",
+    outside: "text-base-content/30 hover:btn-ghost",
+    disabled: "opacity-50 cursor-not-allowed hover:btn-disabled"
+  }
+};
+function DateTimePickerPopup({ selectedDate, month, onMonthChange, onSelect, onTimeChange }) {
+  const customDayModifiers = {
+    selected: selectedDate,
+    "custom-today": (date) => (0, import_date_fns.isToday)(date) && !(selectedDate && (0, import_date_fns.isSameDay)(date, selectedDate))
+  };
+  const customModifiersClassNames = {
+    ...dayPickerStyles.modifiers,
+    "custom-today": "btn btn-outline btn-info min-h-0 h-full"
+  };
+  const handleClick = (0, import_react9.useCallback)((e) => {
+    e.stopPropagation();
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "p-3", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+      import_react_day_picker.DayPicker,
+      {
+        mode: "single",
+        selected: selectedDate,
+        month,
+        onMonthChange,
+        onSelect,
+        captionLayout: "dropdown",
+        fromYear: 1900,
+        toYear: (/* @__PURE__ */ new Date()).getFullYear() + 10,
+        showOutsideDays: true,
+        classNames: dayPickerStyles.classNames,
+        modifiers: customDayModifiers,
+        modifiersClassNames: customModifiersClassNames
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "mt-3 border-t border-base-300 pt-3", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "form-control w-full", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("label", { className: "label", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "label-text", children: "Time" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+        "input",
+        {
+          type: "time",
+          className: "input input-bordered w-full",
+          value: selectedDate ? (0, import_date_fns.format)(selectedDate, "HH:mm") : "",
+          onChange: onTimeChange,
+          onClick: handleClick
+        }
+      )
+    ] }) })
+  ] });
+}
+var MemoizedDateTimePickerPopup = (0, import_react9.memo)(DateTimePickerPopup);
+function DateTimeWidget(props) {
+  const { id, value, onChange, onFocus, onBlur, schema } = props;
+  const initialDate = (0, import_react9.useMemo)(() => value ? new Date(value) : void 0, [value]);
+  const [localDate, setLocalDate] = (0, import_react9.useState)(initialDate);
+  (0, import_react9.useEffect)(() => {
+    setLocalDate(initialDate);
+  }, [initialDate]);
+  const { isOpen, setIsOpen, month, setMonth } = useDatePickerState(initialDate);
+  const containerRef = (0, import_react9.useRef)(null);
+  const inputRef = (0, import_react9.useRef)(null);
+  useClickOutside(containerRef, () => {
+    if (isOpen) {
+      setIsOpen(false);
+      onChange(localDate ? localDate.toISOString() : "");
+      if (onBlur) {
+        onBlur(id, value);
+      }
+    }
+  });
+  (0, import_react9.useEffect)(() => {
+    if (localDate) {
+      setMonth(localDate);
+    }
+  }, [localDate, setMonth]);
+  const handleMonthChange = (0, import_react9.useCallback)((date) => setMonth(date), [setMonth]);
+  const handleSelect = (0, import_react9.useCallback)(
+    (date) => {
+      if (date) {
+        if (localDate) {
+          date.setHours(localDate.getHours(), localDate.getMinutes());
+        }
+        setLocalDate(date);
+      }
+    },
+    [localDate]
+  );
+  const handleTimeChange = (0, import_react9.useCallback)(
+    (e) => {
+      if (localDate) {
+        const [hours, minutes] = e.target.value.split(":");
+        const newDate = new Date(localDate);
+        newDate.setHours(parseInt(hours, 10), parseInt(minutes, 10));
+        setLocalDate(newDate);
+      }
+    },
+    [localDate]
+  );
+  const togglePicker = (0, import_react9.useCallback)(
+    (e) => {
+      e.stopPropagation();
+      setIsOpen((prev) => !prev);
+      if (!isOpen && onFocus) {
+        onFocus(id, value);
+      }
+    },
+    [isOpen, id, onFocus, setIsOpen, value]
+  );
+  const handleFocus = (0, import_react9.useCallback)(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [id, onFocus, value]);
+  const handleBlur = (0, import_react9.useCallback)(() => {
+    if (!isOpen && onBlur) {
+      onBlur(id, value);
+    }
+  }, [id, onBlur, value, isOpen]);
+  const handleKeyDown = (0, import_react9.useCallback)(
+    (e) => {
+      if (e.key === "Enter" || e.key === " ") {
+        togglePicker(e);
+      }
+    },
+    [togglePicker]
+  );
+  const handleContainerClick = (0, import_react9.useCallback)((e) => {
+    e.stopPropagation();
+  }, []);
+  (0, import_react9.useEffect)(() => {
+    const handleEscape = (e) => {
+      if (e.key === "Escape" && isOpen) {
+        setIsOpen(false);
+        if (onBlur) {
+          onBlur(id, value);
+        }
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+    return () => document.removeEventListener("keydown", handleEscape);
+  }, [id, isOpen, onBlur, value]);
+  const handleDoneClick = (0, import_react9.useCallback)(() => {
+    setIsOpen(false);
+    onChange(localDate ? localDate.toISOString() : "");
+    if (onBlur) {
+      onBlur(id, value);
+    }
+    inputRef.current?.focus();
+  }, [localDate, onChange, onBlur, id, value]);
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "form-control my-4 w-full relative", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
+    "div",
+    {
+      className: "w-full",
+      tabIndex: 0,
+      onKeyDown: handleKeyDown,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      ref: inputRef,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
+          "div",
+          {
+            id,
+            className: `input input-bordered w-full flex items-center justify-between cursor-pointer ${isOpen ? "ring-2 ring-primary/50" : ""}`,
+            onClick: togglePicker,
+            role: "button",
+            "aria-haspopup": "true",
+            "aria-expanded": isOpen,
+            tabIndex: -1,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: localDate && (0, import_date_fns.isValid)(localDate) ? "" : "text-base-content/50", children: localDate && (0, import_date_fns.isValid)(localDate) ? (0, import_date_fns.format)(localDate, "PP p") : schema.title }),
+              /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_react_fontawesome2.FontAwesomeIcon, { icon: import_free_solid_svg_icons3.faCalendar, className: "ml-2 h-4 w-4 text-primary" })
+            ]
+          }
+        ),
+        isOpen && /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(
+          "div",
+          {
+            ref: containerRef,
+            className: "absolute z-[100] mt-2 w-full max-w-xs bg-base-100 border border-base-300 shadow-lg rounded-box",
+            onClick: handleContainerClick,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+                MemoizedDateTimePickerPopup,
+                {
+                  selectedDate: localDate,
+                  month,
+                  onMonthChange: handleMonthChange,
+                  onSelect: handleSelect,
+                  onTimeChange: handleTimeChange
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "p-3 flex justify-end border-t border-base-300", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("button", { type: "button", className: "btn btn-sm btn-primary", onClick: handleDoneClick, children: "Done" }) })
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+}
+
+// src/widgets/DateWidget/DateWidget.tsx
+var import_react10 = require("react");
+var import_free_solid_svg_icons4 = require("@fortawesome/free-solid-svg-icons");
+var import_react_fontawesome3 = require("@fortawesome/react-fontawesome");
+var import_date_fns2 = require("date-fns");
+var import_react_day_picker2 = require("react-day-picker");
+var import_style2 = require("react-day-picker/dist/style.css");
+var import_jsx_runtime23 = require("react/jsx-runtime");
+function useDatePickerState2(initialDate) {
+  const [isOpen, setIsOpen] = (0, import_react10.useState)(false);
+  const [month, setMonth] = (0, import_react10.useState)(initialDate ?? /* @__PURE__ */ new Date());
+  return { isOpen, setIsOpen, month, setMonth };
+}
+function useClickOutside2(ref, callback) {
+  (0, import_react10.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (ref.current && !ref.current.contains(event.target)) {
+        callback();
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [ref, callback]);
+}
+var dayPickerStyles2 = {
+  classNames: {
+    [import_react_day_picker2.UI.Root]: "relative",
+    [import_react_day_picker2.UI.Nav]: "hidden",
+    [import_react_day_picker2.UI.Chevron]: "hidden",
+    [import_react_day_picker2.UI.CaptionLabel]: "hidden",
+    [import_react_day_picker2.UI.Dropdowns]: "flex justify-between gap-4 px-4 pb-4",
+    [import_react_day_picker2.UI.Dropdown]: "select select-bordered select-sm w-32",
+    [import_react_day_picker2.UI.MonthsDropdown]: "select select-bordered select-sm",
+    [import_react_day_picker2.UI.YearsDropdown]: "select select-bordered select-sm",
+    [import_react_day_picker2.UI.Months]: "flex justify-center",
+    [import_react_day_picker2.UI.Month]: "w-full",
+    [import_react_day_picker2.UI.MonthCaption]: "flex justify-center",
+    [import_react_day_picker2.UI.MonthGrid]: "w-full",
+    [import_react_day_picker2.UI.Weekdays]: "grid grid-cols-7 text-center border-b mb-2 pb-1 text-base-content/60 uppercase",
+    [import_react_day_picker2.UI.Weekday]: "p-1 font-medium text-base-content/60 text-sm",
+    [import_react_day_picker2.UI.Week]: "grid grid-cols-7",
+    [import_react_day_picker2.UI.Day]: "w-10 h-8 p-0 relative rounded-md",
+    [import_react_day_picker2.UI.DayButton]: "btn btn-ghost absolute inset-0 flex items-center justify-center w-full h-full cursor-pointer rounded-md hover:btn-primary"
+  },
+  modifiers: {
+    selected: "btn btn-accent min-h-0 h-full",
+    outside: "text-base-content/30 hover:btn-ghost",
+    disabled: "opacity-50 cursor-not-allowed hover:btn-disabled"
+  }
+};
+function DatePickerPopup({ selectedDate, month, onMonthChange, onSelect }) {
+  const customDayModifiers = {
+    selected: selectedDate,
+    "custom-today": (date) => (0, import_date_fns2.isToday)(date) && !(selectedDate && (0, import_date_fns2.isSameDay)(date, selectedDate))
+  };
+  const customModifiersClassNames = {
+    ...dayPickerStyles2.modifiers,
+    "custom-today": "btn btn-outline btn-info min-h-0 h-full"
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "p-3", style: { minWidth: "320px", minHeight: "350px" }, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+    import_react_day_picker2.DayPicker,
+    {
+      mode: "single",
+      selected: selectedDate,
+      month,
+      onMonthChange,
+      onSelect,
+      captionLayout: "dropdown",
+      fromYear: 1900,
+      toYear: (/* @__PURE__ */ new Date()).getFullYear() + 10,
+      showOutsideDays: true,
+      classNames: dayPickerStyles2.classNames,
+      modifiers: customDayModifiers,
+      modifiersClassNames: customModifiersClassNames
+    }
+  ) });
+}
+var MemoizedDatePickerPopup = (0, import_react10.memo)(DatePickerPopup);
+function DateWidget(props) {
+  const { id, value, onChange, onFocus, onBlur, schema } = props;
+  const initialDate = (0, import_react10.useMemo)(() => value ? new Date(value) : void 0, [value]);
+  const [localDate, setLocalDate] = (0, import_react10.useState)(initialDate);
+  (0, import_react10.useEffect)(() => {
+    setLocalDate(initialDate);
+  }, [initialDate]);
+  const { isOpen, setIsOpen, month, setMonth } = useDatePickerState2(initialDate);
+  const containerRef = (0, import_react10.useRef)(null);
+  const inputRef = (0, import_react10.useRef)(null);
+  useClickOutside2(containerRef, () => {
+    if (isOpen) {
+      setIsOpen(false);
+      onChange(localDate ? localDate.toISOString() : "");
+      if (onBlur) {
+        onBlur(id, value);
+      }
+    }
+  });
+  (0, import_react10.useEffect)(() => {
+    if (localDate) {
+      setMonth(localDate);
+    }
+  }, [localDate, setMonth]);
+  const handleMonthChange = (0, import_react10.useCallback)((date) => setMonth(date), [setMonth]);
+  const handleSelect = (0, import_react10.useCallback)((date) => {
+    if (date) {
+      date.setHours(0, 0, 0, 0);
+      setLocalDate(date);
+    }
+  }, []);
+  (0, import_react10.useEffect)(() => {
+    let portalContainer = document.getElementById("date-picker-portal");
+    if (!portalContainer) {
+      portalContainer = document.createElement("div");
+      portalContainer.id = "date-picker-portal";
+      document.body.appendChild(portalContainer);
+    }
+    return () => {
+      const container = document.getElementById("date-picker-portal");
+      if (container && document.querySelectorAll(".date-picker-popup").length === 0) {
+        container.remove();
+      }
+    };
+  }, []);
+  const getDocumentAndWindow = () => {
+    let doc = document;
+    let win = window;
+    try {
+      if (window.frameElement) {
+        const iframe = window.frameElement;
+        if (iframe.contentDocument) {
+          doc = iframe.contentDocument;
+        }
+        if (iframe.contentWindow) {
+          win = iframe.contentWindow;
+        }
+      }
+    } catch (e) {
+      console.log("Unable to access parent frame:", e);
+    }
+    return { doc, win };
+  };
+  const renderCalendar = (0, import_react10.useCallback)(() => {
+    if (!containerRef.current || !inputRef.current) {
+      return;
+    }
+    const { win } = getDocumentAndWindow();
+    const inputRect = inputRef.current.getBoundingClientRect();
+    const containerWidth = 320;
+    containerRef.current.style.position = "fixed";
+    containerRef.current.style.top = `${inputRect.bottom + 5}px`;
+    const rightEdge = inputRect.left + containerWidth;
+    const windowWidth = win.innerWidth;
+    if (rightEdge > windowWidth - 20) {
+      containerRef.current.style.left = `${Math.max(20, windowWidth - 20 - containerWidth)}px`;
+    } else {
+      containerRef.current.style.left = `${inputRect.left}px`;
+    }
+    containerRef.current.style.zIndex = "99999";
+  }, [containerRef, inputRef]);
+  (0, import_react10.useEffect)(() => {
+    if (!isOpen) {
+      return;
+    }
+    renderCalendar();
+    window.addEventListener("resize", renderCalendar);
+    window.addEventListener("scroll", renderCalendar);
+    return () => {
+      window.removeEventListener("resize", renderCalendar);
+      window.removeEventListener("scroll", renderCalendar);
+    };
+  }, [isOpen, renderCalendar]);
+  const togglePicker = (0, import_react10.useCallback)(
+    (e) => {
+      e.stopPropagation();
+      setIsOpen((prev) => !prev);
+      if (!isOpen && onFocus) {
+        onFocus(id, value);
+      }
+    },
+    [isOpen, id, onFocus, setIsOpen, value]
+  );
+  const handleFocus = (0, import_react10.useCallback)(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [id, onFocus, value]);
+  const handleBlur = (0, import_react10.useCallback)(() => {
+    if (!isOpen && onBlur) {
+      onBlur(id, value);
+    }
+  }, [id, onBlur, value, isOpen]);
+  (0, import_react10.useEffect)(() => {
+    const handleEscape = (e) => {
+      if (e.key === "Escape" && isOpen) {
+        setIsOpen(false);
+        if (onBlur) {
+          onBlur(id, value);
+        }
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+    return () => document.removeEventListener("keydown", handleEscape);
+  }, [id, isOpen, onBlur, value]);
+  const handleDoneClick = (0, import_react10.useCallback)(() => {
+    setIsOpen(false);
+    onChange(localDate ? localDate.toISOString() : "");
+    if (onBlur) {
+      onBlur(id, value);
+    }
+    inputRef.current?.focus();
+  }, [localDate, onChange, onBlur, id, value]);
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "form-control my-4 w-full relative", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(
+    "div",
+    {
+      className: "w-full",
+      tabIndex: 0,
+      onKeyDown: (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          togglePicker(e);
+        }
+      },
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      ref: inputRef,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(
+          "div",
+          {
+            id,
+            className: `input input-bordered w-full flex items-center justify-between cursor-pointer ${isOpen ? "ring-2 ring-primary/50" : ""}`,
+            onClick: togglePicker,
+            role: "button",
+            "aria-haspopup": "true",
+            "aria-expanded": isOpen,
+            tabIndex: -1,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", { className: localDate && (0, import_date_fns2.isValid)(localDate) ? "" : "text-base-content/50", children: localDate && (0, import_date_fns2.isValid)(localDate) ? (0, import_date_fns2.format)(localDate, "PP") : schema.title }),
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_fontawesome3.FontAwesomeIcon, { icon: import_free_solid_svg_icons4.faCalendar, className: "ml-2 h-4 w-4 text-primary" })
+            ]
+          }
+        ),
+        isOpen && /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(
+          "div",
+          {
+            ref: containerRef,
+            className: "date-picker-popup fixed z-[99999] w-full max-w-xs bg-base-100 border border-base-300 shadow-lg rounded-box",
+            style: {
+              maxHeight: "none",
+              overflow: "visible"
+            },
+            onClick: (e) => e.stopPropagation(),
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+                MemoizedDatePickerPopup,
+                {
+                  selectedDate: localDate,
+                  month,
+                  onMonthChange: handleMonthChange,
+                  onSelect: handleSelect
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "p-3 flex justify-end border-t border-base-300", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { type: "button", className: "btn btn-sm btn-primary", onClick: handleDoneClick, children: "Done" }) })
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+}
+
+// src/widgets/FileWidget/FileWidget.tsx
+var import_react11 = require("react");
+var import_jsx_runtime24 = require("react/jsx-runtime");
+function FileWidget(props) {
+  const { id, required, disabled, readonly, schema, onChange, onFocus, onBlur, options = {} } = props;
+  const isMulti = schema.type === "array" || Boolean(options.multiple);
+  const accept = typeof options.accept === "string" ? options.accept : void 0;
+  const handleChange = (0, import_react11.useCallback)(
+    (event) => {
+      if (!event.target.files) {
+        return;
+      }
+      const fileList = Array.from(event.target.files);
+      if (isMulti) {
+        onChange(fileList);
+      } else {
+        onChange(fileList[0] || null);
+      }
+    },
+    [onChange, isMulti]
+  );
+  const handleFocus = (0, import_react11.useCallback)(
+    (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.files ? Array.from(event.target.files) : null);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = (0, import_react11.useCallback)(
+    (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.files ? Array.from(event.target.files) : null);
+      }
+    },
+    [onBlur, id]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+    "input",
+    {
+      id,
+      type: "file",
+      className: "file-input w-full",
+      required,
+      disabled: disabled || readonly,
+      onChange: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      multiple: isMulti,
+      accept
+    }
+  );
+}
+
+// src/widgets/RadioWidget/RadioWidget.tsx
+var import_react12 = require("react");
+var import_jsx_runtime25 = require("react/jsx-runtime");
+function RadioWidget({
+  id,
+  options,
+  value,
+  required,
+  disabled,
+  readonly,
+  onChange,
+  onFocus,
+  onBlur
+}) {
+  const { enumOptions } = options;
+  const isEnumeratedObject = enumOptions && enumOptions[0]?.value && typeof enumOptions[0].value === "object";
+  const getValue = (option) => {
+    return option.value;
+  };
+  const isChecked = (option) => {
+    if (isEnumeratedObject) {
+      return value && value.name === option.value.name;
+    }
+    return value === option.value;
+  };
+  const handleFocus = (0, import_react12.useCallback)(
+    (event) => {
+      if (onFocus) {
+        const index = Number(event.target.dataset.index);
+        const optionValue = enumOptions?.[index]?.value;
+        onFocus(id, optionValue);
+      }
+    },
+    [onFocus, id, enumOptions]
+  );
+  const handleBlur = (0, import_react12.useCallback)(
+    (event) => {
+      if (onBlur) {
+        const index = Number(event.target.dataset.index);
+        const optionValue = enumOptions?.[index]?.value;
+        onBlur(id, optionValue);
+      }
+    },
+    [onBlur, id, enumOptions]
+  );
+  const handleChange = (0, import_react12.useCallback)(
+    (event) => {
+      const index = Number(event.target.dataset.index);
+      const option = enumOptions?.[index];
+      if (option) {
+        onChange(isEnumeratedObject ? option.value : option.value);
+        event.target.blur();
+      }
+    },
+    [onChange, isEnumeratedObject, enumOptions]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", { className: "form-control", children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", { className: "flex flex-col gap-2 mt-1", children: enumOptions?.map((option, index) => /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)("label", { className: "flex items-center cursor-pointer gap-2", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
+      "input",
+      {
+        type: "radio",
+        id: `${id}-${option.value}`,
+        className: "radio",
+        name: id,
+        value: getValue(option),
+        checked: isChecked(option),
+        required,
+        disabled: disabled || readonly,
+        "data-index": index,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("span", { className: "label-text", children: option.label })
+  ] }, option.value)) }) });
+}
+
+// src/widgets/RangeWidget/RangeWidget.tsx
+var import_react13 = require("react");
+var import_jsx_runtime26 = require("react/jsx-runtime");
+function RangeWidget({
+  id,
+  value,
+  required,
+  disabled,
+  readonly,
+  onChange,
+  onFocus,
+  onBlur,
+  schema
+}) {
+  const handleFocus = (event) => {
+    if (onFocus) {
+      onFocus(id, event.target.value);
+    }
+  };
+  const handleBlur = (event) => {
+    if (onBlur) {
+      onBlur(id, event.target.value);
+    }
+  };
+  const handleChange = (0, import_react13.useCallback)(
+    (event) => {
+      onChange(event.target.value);
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("div", { className: "form-control", children: /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)("div", { className: "flex items-center", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
+      "input",
+      {
+        type: "range",
+        id,
+        className: "range",
+        value: value || schema.default,
+        required,
+        disabled: disabled || readonly,
+        min: schema.minimum,
+        max: schema.maximum,
+        step: schema.multipleOf || 1,
+        onChange: handleChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("span", { className: "label-text ml-4", children: value })
+  ] }) });
+}
+
+// src/widgets/RatingWidget/RatingWidget.tsx
+var import_react14 = require("react");
+var import_jsx_runtime27 = require("react/jsx-runtime");
+function RatingWidget({
+  id,
+  value,
+  required,
+  disabled,
+  readonly,
+  autofocus,
+  onChange,
+  onFocus,
+  onBlur,
+  schema,
+  options
+}) {
+  const { stars = 5, shape = "star", color = "orange", size = "md", colorGradient = false } = options;
+  const numStars = schema.maximum ? Math.min(schema.maximum, 5) : Math.min(Math.max(stars, 1), 5);
+  const min = schema.minimum || 0;
+  const maskClass = shape === "heart" ? "mask-heart" : "mask-star-2";
+  const sizeClass = size === "md" ? "" : `rating-${size}`;
+  const _onChange = (0, import_react14.useCallback)(
+    ({ target: { value: value2 } }) => {
+      onChange(parseInt(value2));
+    },
+    [onChange]
+  );
+  const handleFocus = (0, import_react14.useCallback)(
+    (event) => {
+      if (onFocus) {
+        const starValue = Number(event.target.value);
+        onFocus(id, starValue);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = (0, import_react14.useCallback)(
+    (event) => {
+      if (onBlur) {
+        const starValue = Number(event.target.value);
+        onBlur(id, starValue);
+      }
+    },
+    [onBlur, id]
+  );
+  const getColorClass = (index) => {
+    if (!colorGradient) {
+      return `bg-${color}-400`;
+    }
+    const colors = ["red", "orange", "yellow", "lime", "green"];
+    const colorIdx = Math.min(index, colors.length - 1);
+    return `bg-${colors[colorIdx]}-400`;
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("div", { className: "form-control w-full", children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)("div", { className: `rating gap-1 ${sizeClass}`, children: [...Array(numStars)].map((_, index) => {
+    const starValue = min + index;
+    return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
+      "input",
+      {
+        type: "radio",
+        name: id,
+        value: starValue,
+        checked: value === starValue,
+        onChange: _onChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        className: `mask ${maskClass} ${getColorClass(index)}`,
+        disabled: disabled || readonly,
+        required,
+        autoFocus: autofocus && index === 0,
+        "aria-label": `${starValue} ${shape === "heart" ? "heart" : "star"}${starValue === 1 ? "" : "s"}`
+      },
+      index
+    );
+  }) }) });
+}
+
+// src/widgets/SelectWidget/SelectWidget.tsx
+var import_react15 = require("react");
+var import_utils13 = require("@rjsf/utils");
+var import_jsx_runtime28 = require("react/jsx-runtime");
+function SelectWidget({
+  schema,
+  id,
+  options,
+  label,
+  disabled,
+  placeholder,
+  readonly,
+  value,
+  multiple,
+  onChange,
+  onBlur,
+  onFocus
+}) {
+  const { enumOptions, emptyValue: optEmptyVal } = options;
+  multiple = typeof multiple === "undefined" ? false : !!multiple;
+  const getDisplayValue = (val) => {
+    if (!val) {
+      return "";
+    }
+    if (typeof val === "object") {
+      if (val.name) {
+        return val.name;
+      }
+      return val.label || JSON.stringify(val);
+    }
+    return String(val);
+  };
+  const isEnumeratedObject = enumOptions && enumOptions[0]?.value && typeof enumOptions[0].value === "object";
+  const handleOptionClick = (0, import_react15.useCallback)(
+    (event) => {
+      const index = Number(event.currentTarget.dataset.value);
+      if (isNaN(index)) {
+        return;
+      }
+      if (multiple) {
+        const currentValue = Array.isArray(value) ? value : [];
+        const optionValue = isEnumeratedObject ? enumOptions[index].value : (0, import_utils13.enumOptionsValueForIndex)(String(index), enumOptions, optEmptyVal);
+        const newValue = currentValue.includes(optionValue) ? currentValue.filter((v) => v !== optionValue) : [...currentValue, optionValue];
+        onChange(newValue);
+      } else {
+        onChange(
+          isEnumeratedObject ? enumOptions[index].value : (0, import_utils13.enumOptionsValueForIndex)(String(index), enumOptions, optEmptyVal)
+        );
+      }
+    },
+    [value, multiple, isEnumeratedObject, enumOptions, optEmptyVal, onChange]
+  );
+  const _onBlur = (0, import_react15.useCallback)(
+    ({ target }) => {
+      const dataValue = target?.getAttribute("data-value");
+      if (dataValue !== null) {
+        onBlur(id, (0, import_utils13.enumOptionsValueForIndex)(dataValue, enumOptions, optEmptyVal));
+      }
+    },
+    [onBlur, id, enumOptions, optEmptyVal]
+  );
+  const _onFocus = (0, import_react15.useCallback)(
+    ({ target }) => {
+      const dataValue = target?.getAttribute("data-value");
+      if (dataValue !== null) {
+        onFocus(id, (0, import_utils13.enumOptionsValueForIndex)(dataValue, enumOptions, optEmptyVal));
+      }
+    },
+    [onFocus, id, enumOptions, optEmptyVal]
+  );
+  const selectedIndexes = (0, import_utils13.enumOptionsIndexForValue)(value, enumOptions, multiple);
+  const selectedValues = Array.isArray(selectedIndexes) ? selectedIndexes : [selectedIndexes];
+  const optionsList = enumOptions || (Array.isArray(schema.examples) ? schema.examples.map((example) => ({ value: example, label: example })) : []);
+  return /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("div", { className: "form-control w-full", children: /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)("div", { className: "dropdown w-full", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)(
+      "div",
+      {
+        tabIndex: 0,
+        role: "button",
+        className: `btn btn-outline w-full text-left flex justify-between items-center ${disabled || readonly ? "btn-disabled" : ""}`,
+        onBlur: _onBlur,
+        onFocus: _onFocus,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("span", { className: "truncate", children: selectedValues.length > 0 ? selectedValues.map((index) => optionsList[Number(index)]?.label).join(", ") : placeholder || label || "Select..." }),
+          /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("span", { className: "ml-2", children: "\u25BC" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("ul", { className: "dropdown-content z-[1] bg-base-100 w-full max-h-60 overflow-auto rounded-box shadow-lg", children: optionsList.map(({ label: label2 }, i) => /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
+      "li",
+      {
+        role: "button",
+        tabIndex: 0,
+        className: `px-4 py-2 hover:bg-base-200 cursor-pointer ${selectedValues.includes(String(i)) ? "bg-primary/10" : ""}`,
+        onClick: handleOptionClick,
+        "data-value": i,
+        children: /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)("div", { className: "flex items-center gap-2", children: [
+          multiple && /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
+            "input",
+            {
+              type: "checkbox",
+              className: "checkbox checkbox-sm",
+              checked: selectedValues.includes(String(i)),
+              readOnly: true
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("span", { children: isEnumeratedObject ? label2 : getDisplayValue(label2) })
+        ] })
+      },
+      i
+    )) })
+  ] }) });
+}
+
+// src/widgets/TextareaWidget/TextareaWidget.tsx
+var import_react16 = require("react");
+var import_jsx_runtime29 = require("react/jsx-runtime");
+function TextareaWidget(props) {
+  const { id, value, required, disabled, readonly, onChange, onFocus, onBlur, options } = props;
+  const handleFocus = (0, import_react16.useCallback)(
+    (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.value);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = (0, import_react16.useCallback)(
+    (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.value);
+      }
+    },
+    [onBlur, id]
+  );
+  const handleChange = (0, import_react16.useCallback)(
+    (event) => {
+      onChange(event.target.value);
+    },
+    [onChange]
+  );
+  const rows = options?.rows || 5;
+  return /* @__PURE__ */ (0, import_jsx_runtime29.jsx)("div", { className: "form-control", children: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(
+    "textarea",
+    {
+      id,
+      value: value || "",
+      required,
+      disabled: disabled || readonly,
+      readOnly: readonly,
+      rows,
+      onChange: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      className: "textarea textarea-bordered w-full"
+    }
+  ) });
+}
+
+// src/widgets/TimeWidget/TimeWidget.tsx
+var import_react17 = require("react");
+var import_jsx_runtime30 = require("react/jsx-runtime");
+function TimeWidget(props) {
+  const { id, value, onChange, onFocus, onBlur, required, disabled, readonly } = props;
+  const handleFocus = (0, import_react17.useCallback)(
+    (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.value);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = (0, import_react17.useCallback)(
+    (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.value);
+      }
+    },
+    [onBlur, id]
+  );
+  const handleChange = (0, import_react17.useCallback)(
+    (event) => {
+      onChange(event.target.value);
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)("div", { className: "form-control", children: /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(
+    "input",
+    {
+      type: "time",
+      id,
+      className: "input input-bordered w-full",
+      value: value || "",
+      required,
+      disabled: disabled || readonly,
+      readOnly: readonly,
+      onChange: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur
+    }
+  ) });
+}
+
+// src/widgets/ToggleWidget/ToggleWidget.tsx
+var import_react18 = require("react");
+var import_jsx_runtime31 = require("react/jsx-runtime");
+function ToggleWidget({ id, value, required, disabled, readonly, autofocus, onChange, onFocus, onBlur, options }) {
+  const _onChange = (0, import_react18.useCallback)(
+    ({ target: { checked } }) => onChange(checked),
+    [onChange]
+  );
+  const handleFocus = (0, import_react18.useCallback)(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [onFocus, id, value]);
+  const handleBlur = (0, import_react18.useCallback)(() => {
+    if (onBlur) {
+      onBlur(id, value);
+    }
+  }, [onBlur, id, value]);
+  const { size = "md" } = options;
+  const sizeClass = size !== "md" ? `toggle-${size}` : "";
+  return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("div", { className: "form-control", children: /* @__PURE__ */ (0, import_jsx_runtime31.jsxs)("label", { className: "cursor-pointer label my-auto", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
+      "input",
+      {
+        type: "checkbox",
+        id,
+        checked: value,
+        required,
+        disabled: disabled || readonly,
+        autoFocus: autofocus,
+        onChange: _onChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        className: `toggle ${sizeClass}`
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime31.jsx)("span", { className: "label-text", children: options.label })
+  ] }) });
+}
+
+// src/widgets/Widgets.tsx
+function generateWidgets() {
+  return {
+    AltDateTimeWidget: AltDateTimeWidget_default,
+    AltDateWidget,
+    CheckboxesWidget,
+    CheckboxWidget,
+    DateTimeWidget,
+    DateWidget,
+    FileWidget,
+    RadioWidget,
+    RangeWidget,
+    RatingWidget,
+    SelectWidget,
+    TextareaWidget,
+    TimeWidget,
+    toggle: ToggleWidget
+  };
+}
+var Widgets_default = generateWidgets;
+
+// src/theme/Theme.tsx
+var import_jsx_runtime32 = require("react/jsx-runtime");
+function generateTheme() {
+  const { fields } = (0, import_core2.getDefaultRegistry)();
+  const generatedWidgets = generateWidgets();
+  const templates = generateTemplates();
+  return {
+    templates,
+    widgets: {
+      ...generatedWidgets,
+      boolean: generatedWidgets.toggle
+    },
+    fields
+  };
+}
+var Theme = generateTheme();
+var Theme_default = Theme;
+var ThemeContext = (0, import_react19.createContext)({
+  theme: "night",
+  setTheme: () => {
+  }
+});
+function ThemeProvider({ children }) {
+  const [theme, setTheme] = (0, import_react19.useState)(() => {
+    try {
+      return localStorage.getItem("daisyui-theme") || "cupcake";
+    } catch {
+      return "cupcake";
+    }
+  });
+  const handleSetTheme = (0, import_react19.useCallback)((newTheme) => {
+    try {
+      localStorage.setItem("daisyui-theme", newTheme);
+      setTheme(newTheme);
+    } catch {
+    }
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(ThemeContext.Provider, { value: { theme, setTheme: handleSetTheme }, children });
+}
+var useTheme = () => (0, import_react19.useContext)(ThemeContext);
+
+// src/DaisyUIForm.tsx
+var import_core3 = require("@rjsf/core");
+var DaisyUIForm = (0, import_core3.withTheme)(Theme_default);
+var DaisyUIForm_default = DaisyUIForm;
+
+// src/DaisyUIFrameProvider.tsx
+var import_react20 = require("react");
+var import_jsx_runtime33 = require("react/jsx-runtime");
+function DaisyUIFrameComponent(props) {
+  const { children, subtheme = {}, document: document2 } = props;
+  const theme = (() => {
+    try {
+      if (subtheme?.dataTheme) {
+        localStorage.setItem("daisyui-theme", subtheme.dataTheme);
+        return subtheme.dataTheme;
+      }
+      return localStorage.getItem("daisyui-theme") || "cupcake";
+    } catch {
+      return "cupcake";
+    }
+  })();
+  (0, import_react20.useEffect)(() => {
+    if (document2) {
+      const configScript = document2.createElement("script");
+      configScript.textContent = `
+        window.tailwind = window.tailwind || {};
+        window.tailwind.config = {
+          daisyui: {
+            themes: true,
+          },
+          future: {
+            disableProductionWarning: true
+          }
+        }
+      `;
+      document2.head.appendChild(configScript);
+      const tailwindScript = document2.createElement("script");
+      tailwindScript.src = "https://unpkg.com/@tailwindcss/browser@4.1.3";
+      document2.head.appendChild(tailwindScript);
+      const daisyLink = document2.createElement("link");
+      daisyLink.rel = "stylesheet";
+      daisyLink.href = "https://cdn.jsdelivr.net/npm/daisyui@5.0.20";
+      document2.head.appendChild(daisyLink);
+      const daisyLinkAllThemes = document2.createElement("link");
+      daisyLinkAllThemes.rel = "stylesheet";
+      daisyLinkAllThemes.href = "https://cdn.jsdelivr.net/npm/daisyui@5.0.20/themes.css";
+      document2.head.appendChild(daisyLinkAllThemes);
+      return () => {
+        configScript.remove();
+        tailwindScript.remove();
+        daisyLink.remove();
+        daisyLinkAllThemes.remove();
+      };
+    }
+    return void 0;
+  }, [document2]);
+  return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)("div", { "data-theme": theme, className: "daisy-ui-theme", children });
+}
+var __createDaisyUIFrameProvider = (props) => {
+  return function DaisyUIFrame({ document: document2 }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(DaisyUIFrameComponent, { document: document2, ...props });
+  };
+};
+
+// src/index.ts
+var index_default = (0, import_core4.withTheme)(Theme_default);
+//# sourceMappingURL=index.js.map