@rjsf/daisyui 6.0.0-beta.2

package/dist/chakra-ui.esm.js

@@ -0,0 +1,2192 @@
+// src/index.ts
+import { withTheme as withTheme2 } from "@rjsf/core";
+
+// src/theme/Theme.tsx
+import { createContext, useCallback as useCallback17, useContext, useState as useState4 } from "react";
+import { getDefaultRegistry } from "@rjsf/core";
+
+// src/templates/ArrayFieldItemButtonsTemplate/ArrayFieldItemButtonsTemplate.tsx
+import { useMemo } from "react";
+import {
+  buttonId
+} from "@rjsf/utils";
+import { Fragment, jsx, jsxs } from "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 = useMemo(() => onCopyIndexClick(index), [index, onCopyIndexClick]);
+  const onRemoveClick = useMemo(() => onDropIndexClick(index), [index, onDropIndexClick]);
+  const onArrowUpClick = useMemo(() => onReorderClick(index, index - 1), [index, onReorderClick]);
+  const onArrowDownClick = 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__ */ jsxs(Fragment, { children: [
+    (hasMoveUp || hasMoveDown) && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        MoveUpButton2,
+        {
+          id: buttonId(idSchema, "moveUp"),
+          className: `rjsf-array-item-move-up ${btnClass}`,
+          disabled: disabled || readonly || !hasMoveUp,
+          onClick: onArrowUpClick,
+          uiSchema,
+          registry
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        MoveDownButton2,
+        {
+          id: buttonId(idSchema, "moveDown"),
+          className: `rjsf-array-item-move-down ${btnClass}`,
+          disabled: disabled || readonly || !hasMoveDown,
+          onClick: onArrowDownClick,
+          uiSchema,
+          registry
+        }
+      )
+    ] }),
+    hasCopy && /* @__PURE__ */ jsx(
+      CopyButton2,
+      {
+        id: buttonId(idSchema, "copy"),
+        className: `rjsf-array-item-copy ${btnClass}`,
+        disabled: disabled || readonly,
+        onClick: onCopyClick,
+        uiSchema,
+        registry
+      }
+    ),
+    hasRemove && /* @__PURE__ */ jsx(
+      RemoveButton2,
+      {
+        id: buttonId(idSchema, "remove"),
+        className: `rjsf-array-item-remove ${removeBtnClass}`,
+        disabled: disabled || readonly,
+        onClick: onRemoveClick,
+        uiSchema,
+        registry
+      }
+    )
+  ] });
+  return renderMany ? /* @__PURE__ */ jsx("div", { className: "join", children: buttons }) : buttons;
+}
+
+// src/templates/ArrayFieldItemTemplate/ArrayFieldItemTemplate.tsx
+import {
+  getTemplate,
+  getUiOptions
+} from "@rjsf/utils";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ArrayFieldItemTemplate(props) {
+  const { children, buttonsProps, hasToolbar, registry, uiSchema, index, totalItems } = props;
+  const uiOptions = getUiOptions(uiSchema);
+  const ArrayFieldItemButtonsTemplate2 = 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__ */ jsxs2("fieldset", { className: `fieldset bg-base-100 border border-base-300 p-4 ${borderRadius} ${marginBottom} ${zIndex}`, children: [
+    children,
+    hasToolbar && /* @__PURE__ */ jsx2("div", { className: "flex justify-end mt-2", children: /* @__PURE__ */ jsx2(ArrayFieldItemButtonsTemplate2, { ...buttonsProps }) })
+  ] });
+}
+
+// src/templates/ArrayFieldTemplate/ArrayFieldTemplate.tsx
+import { useCallback } from "react";
+import {
+  getTemplate as getTemplate2,
+  getUiOptions as getUiOptions2,
+  TranslatableString,
+  buttonId as buttonId2
+} from "@rjsf/utils";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ArrayFieldTemplate(props) {
+  const {
+    canAdd,
+    className,
+    disabled,
+    idSchema,
+    items,
+    onAddClick,
+    readonly,
+    registry,
+    required,
+    schema,
+    title,
+    uiSchema
+  } = props;
+  const uiOptions = getUiOptions2(uiSchema);
+  const ArrayFieldDescriptionTemplate = getTemplate2(
+    "ArrayFieldDescriptionTemplate",
+    registry,
+    uiOptions
+  );
+  const ArrayFieldItemTemplate2 = getTemplate2(
+    "ArrayFieldItemTemplate",
+    registry,
+    uiOptions
+  );
+  const ArrayFieldTitleTemplate = getTemplate2(
+    "ArrayFieldTitleTemplate",
+    registry,
+    uiOptions
+  );
+  const {
+    ButtonTemplates: { AddButton: AddButton2 }
+  } = registry.templates;
+  const handleAddClick = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      onAddClick(e);
+    },
+    [onAddClick]
+  );
+  return /* @__PURE__ */ jsxs3("div", { className: `array-field-template ${className}`, children: [
+    /* @__PURE__ */ jsx3(
+      ArrayFieldTitleTemplate,
+      {
+        idSchema,
+        title: uiOptions.title || title,
+        schema,
+        uiSchema,
+        required,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      ArrayFieldDescriptionTemplate,
+      {
+        idSchema,
+        description: uiOptions.description || schema.description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsxs3("div", { className: "flex flex-col gap-4", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "rjsf-array-item-list", children: [
+        items && items.map(({ key, ...itemProps }, index) => /* @__PURE__ */ jsx3(ArrayFieldItemTemplate2, { ...itemProps, index, totalItems: items.length }, key)),
+        items && items.length === 0 && canAdd && /* @__PURE__ */ jsx3("div", { className: "text-center italic text-base-content/70", children: TranslatableString.EmptyArray })
+      ] }),
+      canAdd && /* @__PURE__ */ jsx3("div", { className: "flex justify-end", children: /* @__PURE__ */ jsx3(
+        AddButton2,
+        {
+          id: buttonId2(idSchema, "add"),
+          className: "rjsf-array-item-add btn btn-primary btn-sm",
+          onClick: handleAddClick,
+          disabled: disabled || readonly,
+          uiSchema,
+          registry
+        }
+      ) })
+    ] })
+  ] });
+}
+
+// src/templates/BaseInputTemplate/BaseInputTemplate.tsx
+import { useCallback as useCallback2 } from "react";
+import {
+  getInputProps,
+  ariaDescribedByIds,
+  examplesId
+} from "@rjsf/utils";
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "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 = getInputProps(schema, type, options);
+  const { step, min, max, accept, ...rest } = inputProps;
+  const htmlInputProps = { step, min, max, accept, ...schema.examples ? { list: examplesId(id) } : void 0 };
+  const _onChange = useCallback2(
+    ({ target: { value: value2 } }) => onChange(value2 === "" ? options.emptyValue : value2),
+    [onChange, options]
+  );
+  const _onBlur = useCallback2(
+    ({ target }) => onBlur && onBlur(id, target.value),
+    [onBlur, id]
+  );
+  const _onFocus = useCallback2(
+    ({ target }) => onFocus && onFocus(id, target.value),
+    [onFocus, id]
+  );
+  return /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    /* @__PURE__ */ jsxs4("div", { className: "form-control", children: [
+      /* @__PURE__ */ jsx4("label", { htmlFor: id, className: "label hidden", style: { display: "none" }, children: /* @__PURE__ */ jsx4("span", { className: "label-text", children: label }) }),
+      /* @__PURE__ */ jsx4(
+        "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": ariaDescribedByIds(id, !!schema.examples)
+        }
+      )
+    ] }),
+    Array.isArray(schema.examples) && /* @__PURE__ */ jsx4("datalist", { id: examplesId(id), children: schema.examples.concat(schema.default && !schema.examples.includes(schema.default) ? [schema.default] : []).map((example) => {
+      return /* @__PURE__ */ jsx4("option", { value: example }, example);
+    }) })
+  ] });
+}
+
+// src/templates/ButtonTemplates/AddButton.tsx
+import { TranslatableString as TranslatableString2 } from "@rjsf/utils";
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faArrowDown, faArrowUp, faCopy, faTrash, faPlus } from "@fortawesome/free-solid-svg-icons";
+
+// src/templates/ButtonTemplates/DaisyUIButton.tsx
+import { memo } from "react";
+import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function DaisyUIButton(props) {
+  const { icon, iconType, uiSchema, registry, className, ...otherProps } = props;
+  return /* @__PURE__ */ jsx5("button", { type: "button", className, "aria-label": props.title, ...otherProps, children: /* @__PURE__ */ jsx5(FontAwesomeIcon, { icon, className: "h-5 w-5" }) });
+}
+DaisyUIButton.displayName = "DaisyUIButton";
+var DaisyUIButton_default = memo(DaisyUIButton);
+
+// src/templates/ButtonTemplates/AddButton.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+library.add(faPlus, faCopy, faArrowDown, faArrowUp, faTrash);
+function AddButton({
+  className,
+  onClick,
+  disabled,
+  registry,
+  ...otherProps
+}) {
+  const { translateString } = registry;
+  return /* @__PURE__ */ jsx6("div", { className: "row", children: /* @__PURE__ */ jsx6("p", { className: `col-xs-3 col-xs-offset-9 text-right ${className}`, children: /* @__PURE__ */ jsx6(
+    DaisyUIButton_default,
+    {
+      ...otherProps,
+      iconType: "info",
+      icon: faPlus,
+      className: "btn-add col-xs-12 btn-primary btn-primary-content",
+      title: translateString(TranslatableString2.AddButton),
+      onClick,
+      disabled,
+      registry
+    }
+  ) }) });
+}
+
+// src/templates/ButtonTemplates/SubmitButton.tsx
+import { getSubmitButtonOptions } from "@rjsf/utils";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function SubmitButton({ uiSchema }) {
+  const { submitText, norender, props: submitButtonProps = {} } = getSubmitButtonOptions(uiSchema);
+  if (norender) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx7("div", { children: /* @__PURE__ */ jsx7(
+    "button",
+    {
+      type: "submit",
+      ...submitButtonProps,
+      className: `btn btn-primary btn-primary-content ${submitButtonProps.className || ""}`,
+      children: submitText
+    }
+  ) });
+}
+
+// src/templates/ButtonTemplates/IconButton.tsx
+import { TranslatableString as TranslatableString3 } from "@rjsf/utils";
+import { faCopy as faCopy2, faArrowDown as faArrowDown2, faArrowUp as faArrowUp2, faTrash as faTrash2 } from "@fortawesome/free-solid-svg-icons";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function CopyButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ jsx8(DaisyUIButton_default, { ...props, title: translateString(TranslatableString3.CopyButton), icon: faCopy2 });
+}
+function MoveDownButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ jsx8(
+    DaisyUIButton_default,
+    {
+      ...props,
+      title: translateString(TranslatableString3.MoveDownButton),
+      icon: faArrowDown2
+    }
+  );
+}
+function MoveUpButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ jsx8(
+    DaisyUIButton_default,
+    {
+      ...props,
+      title: translateString(TranslatableString3.MoveUpButton),
+      icon: faArrowUp2
+    }
+  );
+}
+function RemoveButton(props) {
+  const {
+    registry: { translateString }
+  } = props;
+  return /* @__PURE__ */ jsx8(
+    DaisyUIButton_default,
+    {
+      ...props,
+      title: translateString(TranslatableString3.RemoveButton),
+      iconType: "danger",
+      icon: faTrash2
+    }
+  );
+}
+
+// src/templates/DescriptionField/DescriptionField.tsx
+import { RichDescription } from "@rjsf/core";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function DescriptionField(props) {
+  const { id, description, registry, uiSchema } = props;
+  if (!description) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx9("div", { id, className: "description-field my-4", children: /* @__PURE__ */ jsx9("div", { className: "text-sm text-base-content/80", children: /* @__PURE__ */ jsx9(RichDescription, { description, registry, uiSchema }) }) });
+}
+
+// src/templates/ErrorList/ErrorList.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+function ErrorList(props) {
+  const { errors } = props;
+  return /* @__PURE__ */ jsx10("div", { className: "error-list", children: /* @__PURE__ */ jsx10("ul", { className: "list-disc list-inside text-red-600", children: errors.map((error, index) => /* @__PURE__ */ jsx10("li", { children: error.stack }, index)) }) });
+}
+
+// src/templates/FieldErrorTemplate/FieldErrorTemplate.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+function FieldErrorTemplate(props) {
+  const { errors } = props;
+  return /* @__PURE__ */ jsx11("div", { className: "rjsf-field-error-template text-red-600", children: /* @__PURE__ */ jsx11("ul", { className: "list-disc list-inside", children: errors?.map((error, index) => /* @__PURE__ */ jsx11("li", { children: error }, index)) ?? [] }) });
+}
+
+// src/templates/FieldHelpTemplate/FieldHelpTemplate.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function FieldHelpTemplate(props) {
+  const { help } = props;
+  return /* @__PURE__ */ jsx12("div", { className: "rjsf-field-help-template text-gray-500 text-sm", children: /* @__PURE__ */ jsx12("div", { children: help }) });
+}
+
+// src/templates/FieldTemplate/FieldTemplate.tsx
+import { jsx as jsx13, jsxs as jsxs5 } from "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__ */ jsxs5("div", { className: `field-template mb-3 ${classNames || ""}`, ...divProps, children: [
+    displayLabel && !isCheckbox && /* @__PURE__ */ jsx13("label", { htmlFor: id, className: "label", children: /* @__PURE__ */ jsxs5("span", { className: "label-text font-medium", children: [
+      label,
+      required && /* @__PURE__ */ jsx13("span", { className: "text-error ml-1", children: "*" })
+    ] }) }),
+    children,
+    errors,
+    help
+  ] });
+}
+
+// src/templates/GridTemplate/GridTemplate.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+function GridTemplate(props) {
+  const { children, column, ...rest } = props;
+  if (column) {
+    return /* @__PURE__ */ jsx14("div", { className: "flex-grow", ...rest, children });
+  }
+  return /* @__PURE__ */ jsx14("div", { className: "flex flex-wrap gap-4", ...rest, children });
+}
+
+// src/templates/ObjectFieldTemplate/ObjectFieldTemplate.tsx
+import {
+  canExpand,
+  descriptionId,
+  getTemplate as getTemplate3,
+  getUiOptions as getUiOptions3,
+  titleId,
+  buttonId as buttonId3
+} from "@rjsf/utils";
+import { jsx as jsx15, jsxs as jsxs6 } from "react/jsx-runtime";
+function ObjectFieldTemplate(props) {
+  const {
+    description,
+    title,
+    properties,
+    required,
+    disabled,
+    readonly,
+    uiSchema,
+    idSchema,
+    schema,
+    formData,
+    onAddClick,
+    registry
+  } = props;
+  const uiOptions = getUiOptions3(uiSchema);
+  const TitleFieldTemplate = getTemplate3("TitleFieldTemplate", registry, uiOptions);
+  const DescriptionFieldTemplate = getTemplate3(
+    "DescriptionFieldTemplate",
+    registry,
+    uiOptions
+  );
+  const {
+    ButtonTemplates: { AddButton: AddButton2 }
+  } = registry.templates;
+  const isRoot = idSchema.$id === "root";
+  return /* @__PURE__ */ jsxs6("div", { className: `form-control ${isRoot ? "bg-base-100 p-6 rounded-xl shadow-lg" : ""}`, children: [
+    title && /* @__PURE__ */ jsx15(
+      TitleFieldTemplate,
+      {
+        id: titleId(idSchema),
+        title,
+        required,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    description && /* @__PURE__ */ jsx15(
+      DescriptionFieldTemplate,
+      {
+        id: descriptionId(idSchema),
+        description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsxs6("div", { className: `grid grid-cols-1 gap-${description ? 3 : 4} ${isRoot ? "" : "mb-4"}`, children: [
+      properties.map(
+        (element, index) => element.hidden ? element.content : /* @__PURE__ */ jsx15(
+          "div",
+          {
+            className: idSchema.$id === "root" && element.name === "tasks" ? "mt-2" : "",
+            children: element.content
+          },
+          `${idSchema.$id}-${element.name}-${index}`
+        )
+      ),
+      canExpand(schema, uiSchema, formData) && /* @__PURE__ */ jsx15("div", { className: "flex justify-end", children: /* @__PURE__ */ jsx15(
+        AddButton2,
+        {
+          id: buttonId3(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
+import { getUiOptions as getUiOptions4 } from "@rjsf/utils";
+import { jsx as jsx16, jsxs as jsxs7 } from "react/jsx-runtime";
+function TitleField(props) {
+  const { id, title, uiSchema } = props;
+  const uiOptions = getUiOptions4(uiSchema);
+  return /* @__PURE__ */ jsxs7("div", { id, className: "title-field mb-6", children: [
+    /* @__PURE__ */ jsx16("h2", { className: "text-3xl font-bold text-primary mb-2", children: uiOptions.title || title }),
+    /* @__PURE__ */ jsx16("div", { className: "divider divider-primary" })
+  ] });
+}
+
+// src/templates/WrapIfAdditionalTemplate/WrapIfAdditionalTemplate.tsx
+import { useCallback as useCallback3 } from "react";
+import {
+  TranslatableString as TranslatableString4,
+  buttonId as buttonId4
+} from "@rjsf/utils";
+import { jsx as jsx17, jsxs as jsxs8 } from "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 = useCallback3(
+    (event) => {
+      onKeyChange(event.target.value);
+    },
+    [onKeyChange]
+  );
+  const handleRemove = useCallback3(() => {
+    onDropPropertyClick(label)();
+  }, [onDropPropertyClick, label]);
+  return /* @__PURE__ */ jsxs8("div", { className: `wrap-if-additional-template ${classNames}`, ...rest, children: [
+    /* @__PURE__ */ jsxs8("div", { className: "flex items-center", children: [
+      /* @__PURE__ */ jsx17(
+        "input",
+        {
+          type: "text",
+          className: "input input-bordered",
+          id: `${id}-key`,
+          onBlur: handleBlur,
+          defaultValue: label,
+          disabled: disabled || readonly
+        }
+      ),
+      schema.additionalProperties && /* @__PURE__ */ jsx17(
+        "button",
+        {
+          id: buttonId4(id, "remove"),
+          className: "rjsf-array-item-remove btn btn-danger ml-2",
+          onClick: handleRemove,
+          disabled: disabled || readonly,
+          children: translateString(TranslatableString4.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
+import { jsx as jsx18 } from "react/jsx-runtime";
+function AltDateTimeWidget({
+  time = true,
+  ...props
+}) {
+  const { AltDateWidget: AltDateWidget2 } = props.registry.widgets;
+  return /* @__PURE__ */ jsx18(AltDateWidget2, { time, ...props });
+}
+var AltDateTimeWidget_default = AltDateTimeWidget;
+
+// src/widgets/AltDateWidget/AltDateWidget.tsx
+import { useCallback as useCallback4, useEffect, useReducer, useState } from "react";
+import {
+  ariaDescribedByIds as ariaDescribedByIds2,
+  TranslatableString as TranslatableString5,
+  parseDateString,
+  toDateString,
+  dateRangeOptions
+} from "@rjsf/utils";
+import { jsx as jsx19, jsxs as jsxs9 } from "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 = useCallback4(
+    (value2) => {
+      select(type, value2);
+    },
+    [select, type]
+  );
+  return /* @__PURE__ */ jsx19(
+    SelectWidget2,
+    {
+      schema: { type: "integer" },
+      id,
+      name,
+      className: "select select-bordered select-sm w-full",
+      options: { enumOptions: dateRangeOptions(range[0], range[1]) },
+      placeholder: type,
+      value,
+      disabled,
+      readonly,
+      autofocus,
+      onChange: handleChange,
+      onBlur,
+      onFocus,
+      registry,
+      label: "",
+      "aria-describedby": ariaDescribedByIds2(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] = useState(value);
+  const initialState = parseDateString(value, time);
+  const dateReducer = (state2, action) => {
+    return { ...state2, ...action };
+  };
+  const [state, setState] = useReducer(dateReducer, initialState);
+  useEffect(() => {
+    const rjsfDateObj = convertToRJSFDateObject(state);
+    const stateValue = toDateString(rjsfDateObj, time);
+    if (readyForChange(state, time) && stateValue !== value) {
+      onChange(stateValue);
+    } else if (lastValue !== value) {
+      setLastValue(value);
+      setState(parseDateString(value, time));
+    }
+  }, [time, value, onChange, state, lastValue]);
+  const handleChange = useCallback4((property, value2) => {
+    setState({ [property]: value2 });
+  }, []);
+  const handleSetNow = useCallback4(
+    (event) => {
+      event.preventDefault();
+      if (disabled || readonly) {
+        return;
+      }
+      const nextState = parseDateString((/* @__PURE__ */ new Date()).toJSON(), time);
+      const rjsfDateObj = convertToRJSFDateObject(nextState);
+      onChange(toDateString(rjsfDateObj, time));
+    },
+    [disabled, readonly, time, onChange]
+  );
+  const handleClear = useCallback4(
+    (event) => {
+      event.preventDefault();
+      if (disabled || readonly) {
+        return;
+      }
+      onChange(void 0);
+    },
+    [disabled, readonly, onChange]
+  );
+  return /* @__PURE__ */ jsxs9("div", { className: "space-y-3", children: [
+    /* @__PURE__ */ jsx19("div", { className: "grid grid-cols-3 gap-2", children: getDateElementProps(
+      state,
+      time,
+      options.yearsRange,
+      options.format
+    ).map((elemProps, i) => /* @__PURE__ */ jsxs9("div", { className: "form-control", children: [
+      /* @__PURE__ */ jsx19("label", { className: "label", children: /* @__PURE__ */ jsx19("span", { className: "label-text capitalize", children: elemProps.type }) }),
+      /* @__PURE__ */ jsx19(
+        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__ */ jsxs9("div", { className: "flex justify-start space-x-2", children: [
+      (options.hideNowButton !== void 0 ? !options.hideNowButton : true) && /* @__PURE__ */ jsx19(
+        "button",
+        {
+          type: "button",
+          className: "btn btn-sm btn-primary",
+          onClick: handleSetNow,
+          disabled: disabled || readonly,
+          children: translateString(TranslatableString5.NowLabel)
+        }
+      ),
+      (options.hideClearButton !== void 0 ? !options.hideClearButton : true) && /* @__PURE__ */ jsx19(
+        "button",
+        {
+          type: "button",
+          className: "btn btn-sm btn-secondary",
+          onClick: handleClear,
+          disabled: disabled || readonly,
+          children: translateString(TranslatableString5.ClearLabel)
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/widgets/CheckboxWidget/CheckboxWidget.tsx
+import { useCallback as useCallback5 } from "react";
+import { getTemplate as getTemplate4, descriptionId as descriptionId2 } from "@rjsf/utils";
+import { jsx as jsx20, jsxs as jsxs10 } from "react/jsx-runtime";
+function CheckboxWidget(props) {
+  const {
+    id,
+    value,
+    required,
+    disabled,
+    hideLabel,
+    label,
+    readonly,
+    registry,
+    options,
+    schema,
+    uiSchema,
+    onChange,
+    onFocus,
+    onBlur
+  } = props;
+  const DescriptionFieldTemplate = getTemplate4(
+    "DescriptionFieldTemplate",
+    registry,
+    options
+  );
+  const description = options.description || schema.description;
+  const handleFocus = useCallback5(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [onFocus, id, value]);
+  const handleBlur = useCallback5(() => {
+    if (onBlur) {
+      onBlur(id, value);
+    }
+  }, [onBlur, id, value]);
+  const handleChange = useCallback5(
+    (event) => {
+      onChange(event.target.checked);
+    },
+    [onChange]
+  );
+  const input = /* @__PURE__ */ jsx20(
+    "input",
+    {
+      type: "checkbox",
+      id,
+      checked: value,
+      required,
+      disabled: disabled || readonly,
+      onChange: handleChange,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      className: "checkbox"
+    }
+  );
+  return /* @__PURE__ */ jsxs10("div", { className: "form-control", children: [
+    !hideLabel && description && /* @__PURE__ */ jsx20(
+      DescriptionFieldTemplate,
+      {
+        id: descriptionId2(id),
+        description,
+        schema,
+        uiSchema,
+        registry
+      }
+    ),
+    hideLabel || !label ? input : /* @__PURE__ */ jsxs10("label", { className: "label cursor-pointer justify-start", children: [
+      /* @__PURE__ */ jsx20("div", { className: "mr-2", children: input }),
+      /* @__PURE__ */ jsxs10("span", { className: "label-text", children: [
+        label,
+        required && /* @__PURE__ */ jsx20("span", { className: "text-error ml-1", children: "*" })
+      ] })
+    ] })
+  ] });
+}
+
+// src/widgets/CheckboxesWidget/CheckboxesWidget.tsx
+import { useCallback as useCallback6 } from "react";
+import { jsx as jsx21, jsxs as jsxs11 } from "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 = useCallback6(
+    (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 = useCallback6(
+    (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 = useCallback6(
+    (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 = useCallback6(
+    (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__ */ jsx21("div", { className: "form-control", children: /* @__PURE__ */ jsx21("div", { className: "flex flex-col gap-2 mt-1", children: enumOptions?.map((option, index) => /* @__PURE__ */ jsxs11("label", { className: "flex items-center cursor-pointer gap-2", children: [
+    /* @__PURE__ */ jsx21(
+      "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__ */ jsx21("span", { className: "label-text", children: option.label })
+  ] }, option.value)) }) });
+}
+
+// src/widgets/DateTimeWidget/DateTimeWidget.tsx
+import { memo as memo2, useCallback as useCallback7, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+import { faCalendar } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon as FontAwesomeIcon2 } from "@fortawesome/react-fontawesome";
+import { format, isSameDay, isToday, isValid } from "date-fns";
+import { DayPicker, UI } from "react-day-picker";
+import "react-day-picker/dist/style.css";
+import { jsx as jsx22, jsxs as jsxs12 } from "react/jsx-runtime";
+function useDatePickerState(initialDate) {
+  const [isOpen, setIsOpen] = useState2(false);
+  const [month, setMonth] = useState2(initialDate ?? /* @__PURE__ */ new Date());
+  return { isOpen, setIsOpen, month, setMonth };
+}
+function useClickOutside(ref, callback) {
+  useEffect2(() => {
+    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: {
+    [UI.Root]: "relative",
+    [UI.Nav]: "hidden",
+    [UI.Chevron]: "hidden",
+    [UI.CaptionLabel]: "hidden",
+    [UI.Dropdowns]: "flex justify-between gap-4 px-4 pb-4",
+    [UI.Dropdown]: "select select-bordered select-sm w-32",
+    [UI.MonthsDropdown]: "select select-bordered select-sm",
+    [UI.YearsDropdown]: "select select-bordered select-sm",
+    [UI.Months]: "flex justify-center",
+    [UI.Month]: "w-full",
+    [UI.MonthCaption]: "flex justify-center",
+    [UI.MonthGrid]: "w-full",
+    [UI.Weekdays]: "grid grid-cols-7 text-center border-b mb-2 pb-1 text-base-content/60 uppercase",
+    [UI.Weekday]: "p-1 font-medium text-base-content/60 text-sm",
+    [UI.Week]: "grid grid-cols-7",
+    [UI.Day]: "w-10 h-8 p-0 relative rounded-md",
+    [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) => isToday(date) && !(selectedDate && isSameDay(date, selectedDate))
+  };
+  const customModifiersClassNames = {
+    ...dayPickerStyles.modifiers,
+    "custom-today": "btn btn-outline btn-info min-h-0 h-full"
+  };
+  const handleClick = useCallback7((e) => {
+    e.stopPropagation();
+  }, []);
+  return /* @__PURE__ */ jsxs12("div", { className: "p-3", children: [
+    /* @__PURE__ */ jsx22(
+      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__ */ jsx22("div", { className: "mt-3 border-t border-base-300 pt-3", children: /* @__PURE__ */ jsxs12("div", { className: "form-control w-full", children: [
+      /* @__PURE__ */ jsx22("label", { className: "label", children: /* @__PURE__ */ jsx22("span", { className: "label-text", children: "Time" }) }),
+      /* @__PURE__ */ jsx22(
+        "input",
+        {
+          type: "time",
+          className: "input input-bordered w-full",
+          value: selectedDate ? format(selectedDate, "HH:mm") : "",
+          onChange: onTimeChange,
+          onClick: handleClick
+        }
+      )
+    ] }) })
+  ] });
+}
+var MemoizedDateTimePickerPopup = memo2(DateTimePickerPopup);
+function DateTimeWidget(props) {
+  const { id, value, onChange, onFocus, onBlur, schema } = props;
+  const initialDate = useMemo2(() => value ? new Date(value) : void 0, [value]);
+  const [localDate, setLocalDate] = useState2(initialDate);
+  useEffect2(() => {
+    setLocalDate(initialDate);
+  }, [initialDate]);
+  const { isOpen, setIsOpen, month, setMonth } = useDatePickerState(initialDate);
+  const containerRef = useRef(null);
+  const inputRef = useRef(null);
+  useClickOutside(containerRef, () => {
+    if (isOpen) {
+      setIsOpen(false);
+      onChange(localDate ? localDate.toISOString() : "");
+      if (onBlur) {
+        onBlur(id, value);
+      }
+    }
+  });
+  useEffect2(() => {
+    if (localDate) {
+      setMonth(localDate);
+    }
+  }, [localDate, setMonth]);
+  const handleMonthChange = useCallback7((date) => setMonth(date), [setMonth]);
+  const handleSelect = useCallback7(
+    (date) => {
+      if (date) {
+        if (localDate) {
+          date.setHours(localDate.getHours(), localDate.getMinutes());
+        }
+        setLocalDate(date);
+      }
+    },
+    [localDate]
+  );
+  const handleTimeChange = useCallback7(
+    (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 = useCallback7(
+    (e) => {
+      e.stopPropagation();
+      setIsOpen((prev) => !prev);
+      if (!isOpen && onFocus) {
+        onFocus(id, value);
+      }
+    },
+    [isOpen, id, onFocus, setIsOpen, value]
+  );
+  const handleFocus = useCallback7(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [id, onFocus, value]);
+  const handleBlur = useCallback7(() => {
+    if (!isOpen && onBlur) {
+      onBlur(id, value);
+    }
+  }, [id, onBlur, value, isOpen]);
+  const handleKeyDown = useCallback7(
+    (e) => {
+      if (e.key === "Enter" || e.key === " ") {
+        togglePicker(e);
+      }
+    },
+    [togglePicker]
+  );
+  const handleContainerClick = useCallback7((e) => {
+    e.stopPropagation();
+  }, []);
+  useEffect2(() => {
+    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 = useCallback7(() => {
+    setIsOpen(false);
+    onChange(localDate ? localDate.toISOString() : "");
+    if (onBlur) {
+      onBlur(id, value);
+    }
+    inputRef.current?.focus();
+  }, [localDate, onChange, onBlur, id, value]);
+  return /* @__PURE__ */ jsx22("div", { className: "form-control my-4 w-full relative", children: /* @__PURE__ */ jsxs12(
+    "div",
+    {
+      className: "w-full",
+      tabIndex: 0,
+      onKeyDown: handleKeyDown,
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      ref: inputRef,
+      children: [
+        /* @__PURE__ */ jsxs12(
+          "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__ */ jsx22("span", { className: localDate && isValid(localDate) ? "" : "text-base-content/50", children: localDate && isValid(localDate) ? format(localDate, "PP p") : schema.title }),
+              /* @__PURE__ */ jsx22(FontAwesomeIcon2, { icon: faCalendar, className: "ml-2 h-4 w-4 text-primary" })
+            ]
+          }
+        ),
+        isOpen && /* @__PURE__ */ jsxs12(
+          "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__ */ jsx22(
+                MemoizedDateTimePickerPopup,
+                {
+                  selectedDate: localDate,
+                  month,
+                  onMonthChange: handleMonthChange,
+                  onSelect: handleSelect,
+                  onTimeChange: handleTimeChange
+                }
+              ),
+              /* @__PURE__ */ jsx22("div", { className: "p-3 flex justify-end border-t border-base-300", children: /* @__PURE__ */ jsx22("button", { type: "button", className: "btn btn-sm btn-primary", onClick: handleDoneClick, children: "Done" }) })
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+}
+
+// src/widgets/DateWidget/DateWidget.tsx
+import { memo as memo3, useCallback as useCallback8, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2, useState as useState3 } from "react";
+import { faCalendar as faCalendar2 } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon as FontAwesomeIcon3 } from "@fortawesome/react-fontawesome";
+import { format as format2, isSameDay as isSameDay2, isToday as isToday2, isValid as isValid2 } from "date-fns";
+import { DayPicker as DayPicker2, UI as UI2 } from "react-day-picker";
+import "react-day-picker/dist/style.css";
+import { jsx as jsx23, jsxs as jsxs13 } from "react/jsx-runtime";
+function useDatePickerState2(initialDate) {
+  const [isOpen, setIsOpen] = useState3(false);
+  const [month, setMonth] = useState3(initialDate ?? /* @__PURE__ */ new Date());
+  return { isOpen, setIsOpen, month, setMonth };
+}
+function useClickOutside2(ref, callback) {
+  useEffect3(() => {
+    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: {
+    [UI2.Root]: "relative",
+    [UI2.Nav]: "hidden",
+    [UI2.Chevron]: "hidden",
+    [UI2.CaptionLabel]: "hidden",
+    [UI2.Dropdowns]: "flex justify-between gap-4 px-4 pb-4",
+    [UI2.Dropdown]: "select select-bordered select-sm w-32",
+    [UI2.MonthsDropdown]: "select select-bordered select-sm",
+    [UI2.YearsDropdown]: "select select-bordered select-sm",
+    [UI2.Months]: "flex justify-center",
+    [UI2.Month]: "w-full",
+    [UI2.MonthCaption]: "flex justify-center",
+    [UI2.MonthGrid]: "w-full",
+    [UI2.Weekdays]: "grid grid-cols-7 text-center border-b mb-2 pb-1 text-base-content/60 uppercase",
+    [UI2.Weekday]: "p-1 font-medium text-base-content/60 text-sm",
+    [UI2.Week]: "grid grid-cols-7",
+    [UI2.Day]: "w-10 h-8 p-0 relative rounded-md",
+    [UI2.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) => isToday2(date) && !(selectedDate && isSameDay2(date, selectedDate))
+  };
+  const customModifiersClassNames = {
+    ...dayPickerStyles2.modifiers,
+    "custom-today": "btn btn-outline btn-info min-h-0 h-full"
+  };
+  return /* @__PURE__ */ jsx23("div", { className: "p-3", style: { minWidth: "320px", minHeight: "350px" }, children: /* @__PURE__ */ jsx23(
+    DayPicker2,
+    {
+      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 = memo3(DatePickerPopup);
+function DateWidget(props) {
+  const { id, value, onChange, onFocus, onBlur, schema } = props;
+  const initialDate = useMemo3(() => value ? new Date(value) : void 0, [value]);
+  const [localDate, setLocalDate] = useState3(initialDate);
+  useEffect3(() => {
+    setLocalDate(initialDate);
+  }, [initialDate]);
+  const { isOpen, setIsOpen, month, setMonth } = useDatePickerState2(initialDate);
+  const containerRef = useRef2(null);
+  const inputRef = useRef2(null);
+  useClickOutside2(containerRef, () => {
+    if (isOpen) {
+      setIsOpen(false);
+      onChange(localDate ? localDate.toISOString() : "");
+      if (onBlur) {
+        onBlur(id, value);
+      }
+    }
+  });
+  useEffect3(() => {
+    if (localDate) {
+      setMonth(localDate);
+    }
+  }, [localDate, setMonth]);
+  const handleMonthChange = useCallback8((date) => setMonth(date), [setMonth]);
+  const handleSelect = useCallback8((date) => {
+    if (date) {
+      date.setHours(0, 0, 0, 0);
+      setLocalDate(date);
+    }
+  }, []);
+  useEffect3(() => {
+    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 = useCallback8(() => {
+    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]);
+  useEffect3(() => {
+    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 = useCallback8(
+    (e) => {
+      e.stopPropagation();
+      setIsOpen((prev) => !prev);
+      if (!isOpen && onFocus) {
+        onFocus(id, value);
+      }
+    },
+    [isOpen, id, onFocus, setIsOpen, value]
+  );
+  const handleFocus = useCallback8(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [id, onFocus, value]);
+  const handleBlur = useCallback8(() => {
+    if (!isOpen && onBlur) {
+      onBlur(id, value);
+    }
+  }, [id, onBlur, value, isOpen]);
+  useEffect3(() => {
+    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 = useCallback8(() => {
+    setIsOpen(false);
+    onChange(localDate ? localDate.toISOString() : "");
+    if (onBlur) {
+      onBlur(id, value);
+    }
+    inputRef.current?.focus();
+  }, [localDate, onChange, onBlur, id, value]);
+  return /* @__PURE__ */ jsx23("div", { className: "form-control my-4 w-full relative", children: /* @__PURE__ */ jsxs13(
+    "div",
+    {
+      className: "w-full",
+      tabIndex: 0,
+      onKeyDown: (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          togglePicker(e);
+        }
+      },
+      onFocus: handleFocus,
+      onBlur: handleBlur,
+      ref: inputRef,
+      children: [
+        /* @__PURE__ */ jsxs13(
+          "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__ */ jsx23("span", { className: localDate && isValid2(localDate) ? "" : "text-base-content/50", children: localDate && isValid2(localDate) ? format2(localDate, "PP") : schema.title }),
+              /* @__PURE__ */ jsx23(FontAwesomeIcon3, { icon: faCalendar2, className: "ml-2 h-4 w-4 text-primary" })
+            ]
+          }
+        ),
+        isOpen && /* @__PURE__ */ jsxs13(
+          "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__ */ jsx23(
+                MemoizedDatePickerPopup,
+                {
+                  selectedDate: localDate,
+                  month,
+                  onMonthChange: handleMonthChange,
+                  onSelect: handleSelect
+                }
+              ),
+              /* @__PURE__ */ jsx23("div", { className: "p-3 flex justify-end border-t border-base-300", children: /* @__PURE__ */ jsx23("button", { type: "button", className: "btn btn-sm btn-primary", onClick: handleDoneClick, children: "Done" }) })
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+}
+
+// src/widgets/FileWidget/FileWidget.tsx
+import { useCallback as useCallback9 } from "react";
+import { jsx as jsx24 } from "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 = useCallback9(
+    (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 = useCallback9(
+    (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.files ? Array.from(event.target.files) : null);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = useCallback9(
+    (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.files ? Array.from(event.target.files) : null);
+      }
+    },
+    [onBlur, id]
+  );
+  return /* @__PURE__ */ jsx24(
+    "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
+import { useCallback as useCallback10 } from "react";
+import { jsx as jsx25, jsxs as jsxs14 } from "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 = useCallback10(
+    (event) => {
+      if (onFocus) {
+        const index = Number(event.target.dataset.index);
+        const optionValue = enumOptions?.[index]?.value;
+        onFocus(id, optionValue);
+      }
+    },
+    [onFocus, id, enumOptions]
+  );
+  const handleBlur = useCallback10(
+    (event) => {
+      if (onBlur) {
+        const index = Number(event.target.dataset.index);
+        const optionValue = enumOptions?.[index]?.value;
+        onBlur(id, optionValue);
+      }
+    },
+    [onBlur, id, enumOptions]
+  );
+  const handleChange = useCallback10(
+    (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__ */ jsx25("div", { className: "form-control", children: /* @__PURE__ */ jsx25("div", { className: "flex flex-col gap-2 mt-1", children: enumOptions?.map((option, index) => /* @__PURE__ */ jsxs14("label", { className: "flex items-center cursor-pointer gap-2", children: [
+    /* @__PURE__ */ jsx25(
+      "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__ */ jsx25("span", { className: "label-text", children: option.label })
+  ] }, option.value)) }) });
+}
+
+// src/widgets/RangeWidget/RangeWidget.tsx
+import { useCallback as useCallback11 } from "react";
+import { jsx as jsx26, jsxs as jsxs15 } from "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 = useCallback11(
+    (event) => {
+      onChange(event.target.value);
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ jsx26("div", { className: "form-control", children: /* @__PURE__ */ jsxs15("div", { className: "flex items-center", children: [
+    /* @__PURE__ */ jsx26(
+      "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__ */ jsx26("span", { className: "label-text ml-4", children: value })
+  ] }) });
+}
+
+// src/widgets/RatingWidget/RatingWidget.tsx
+import { useCallback as useCallback12 } from "react";
+import { jsx as jsx27 } from "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 = useCallback12(
+    ({ target: { value: value2 } }) => {
+      onChange(parseInt(value2));
+    },
+    [onChange]
+  );
+  const handleFocus = useCallback12(
+    (event) => {
+      if (onFocus) {
+        const starValue = Number(event.target.value);
+        onFocus(id, starValue);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = useCallback12(
+    (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__ */ jsx27("div", { className: "form-control w-full", children: /* @__PURE__ */ jsx27("div", { className: `rating gap-1 ${sizeClass}`, children: [...Array(numStars)].map((_, index) => {
+    const starValue = min + index;
+    return /* @__PURE__ */ jsx27(
+      "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
+import { useCallback as useCallback13 } from "react";
+import {
+  enumOptionsIndexForValue,
+  enumOptionsValueForIndex
+} from "@rjsf/utils";
+import { jsx as jsx28, jsxs as jsxs16 } from "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 = useCallback13(
+    (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 : 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 : enumOptionsValueForIndex(String(index), enumOptions, optEmptyVal)
+        );
+      }
+    },
+    [value, multiple, isEnumeratedObject, enumOptions, optEmptyVal, onChange]
+  );
+  const _onBlur = useCallback13(
+    ({ target }) => {
+      const dataValue = target?.getAttribute("data-value");
+      if (dataValue !== null) {
+        onBlur(id, enumOptionsValueForIndex(dataValue, enumOptions, optEmptyVal));
+      }
+    },
+    [onBlur, id, enumOptions, optEmptyVal]
+  );
+  const _onFocus = useCallback13(
+    ({ target }) => {
+      const dataValue = target?.getAttribute("data-value");
+      if (dataValue !== null) {
+        onFocus(id, enumOptionsValueForIndex(dataValue, enumOptions, optEmptyVal));
+      }
+    },
+    [onFocus, id, enumOptions, optEmptyVal]
+  );
+  const selectedIndexes = 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__ */ jsx28("div", { className: "form-control w-full", children: /* @__PURE__ */ jsxs16("div", { className: "dropdown w-full", children: [
+    /* @__PURE__ */ jsxs16(
+      "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__ */ jsx28("span", { className: "truncate", children: selectedValues.length > 0 ? selectedValues.map((index) => optionsList[Number(index)]?.label).join(", ") : placeholder || label || "Select..." }),
+          /* @__PURE__ */ jsx28("span", { className: "ml-2", children: "\u25BC" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx28("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__ */ jsx28(
+      "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__ */ jsxs16("div", { className: "flex items-center gap-2", children: [
+          multiple && /* @__PURE__ */ jsx28(
+            "input",
+            {
+              type: "checkbox",
+              className: "checkbox checkbox-sm",
+              checked: selectedValues.includes(String(i)),
+              readOnly: true
+            }
+          ),
+          /* @__PURE__ */ jsx28("span", { children: isEnumeratedObject ? label2 : getDisplayValue(label2) })
+        ] })
+      },
+      i
+    )) })
+  ] }) });
+}
+
+// src/widgets/TextareaWidget/TextareaWidget.tsx
+import { useCallback as useCallback14 } from "react";
+import { jsx as jsx29 } from "react/jsx-runtime";
+function TextareaWidget(props) {
+  const { id, value, required, disabled, readonly, onChange, onFocus, onBlur, options } = props;
+  const handleFocus = useCallback14(
+    (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.value);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = useCallback14(
+    (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.value);
+      }
+    },
+    [onBlur, id]
+  );
+  const handleChange = useCallback14(
+    (event) => {
+      onChange(event.target.value);
+    },
+    [onChange]
+  );
+  const rows = options?.rows || 5;
+  return /* @__PURE__ */ jsx29("div", { className: "form-control", children: /* @__PURE__ */ jsx29(
+    "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
+import { useCallback as useCallback15 } from "react";
+import { jsx as jsx30 } from "react/jsx-runtime";
+function TimeWidget(props) {
+  const { id, value, onChange, onFocus, onBlur, required, disabled, readonly } = props;
+  const handleFocus = useCallback15(
+    (event) => {
+      if (onFocus) {
+        onFocus(id, event.target.value);
+      }
+    },
+    [onFocus, id]
+  );
+  const handleBlur = useCallback15(
+    (event) => {
+      if (onBlur) {
+        onBlur(id, event.target.value);
+      }
+    },
+    [onBlur, id]
+  );
+  const handleChange = useCallback15(
+    (event) => {
+      onChange(event.target.value);
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ jsx30("div", { className: "form-control", children: /* @__PURE__ */ jsx30(
+    "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
+import { useCallback as useCallback16 } from "react";
+import { jsx as jsx31, jsxs as jsxs17 } from "react/jsx-runtime";
+function ToggleWidget({ id, value, required, disabled, readonly, autofocus, onChange, onFocus, onBlur, options }) {
+  const _onChange = useCallback16(
+    ({ target: { checked } }) => onChange(checked),
+    [onChange]
+  );
+  const handleFocus = useCallback16(() => {
+    if (onFocus) {
+      onFocus(id, value);
+    }
+  }, [onFocus, id, value]);
+  const handleBlur = useCallback16(() => {
+    if (onBlur) {
+      onBlur(id, value);
+    }
+  }, [onBlur, id, value]);
+  const { size = "md" } = options;
+  const sizeClass = size !== "md" ? `toggle-${size}` : "";
+  return /* @__PURE__ */ jsx31("div", { className: "form-control", children: /* @__PURE__ */ jsxs17("label", { className: "cursor-pointer label my-auto", children: [
+    /* @__PURE__ */ jsx31(
+      "input",
+      {
+        type: "checkbox",
+        id,
+        checked: value,
+        required,
+        disabled: disabled || readonly,
+        autoFocus: autofocus,
+        onChange: _onChange,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        className: `toggle ${sizeClass}`
+      }
+    ),
+    /* @__PURE__ */ jsx31("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
+import { jsx as jsx32 } from "react/jsx-runtime";
+function generateTheme() {
+  const { fields } = getDefaultRegistry();
+  const generatedWidgets = generateWidgets();
+  const templates = generateTemplates();
+  return {
+    templates,
+    widgets: {
+      ...generatedWidgets,
+      boolean: generatedWidgets.toggle
+    },
+    fields
+  };
+}
+var Theme = generateTheme();
+var Theme_default = Theme;
+var ThemeContext = createContext({
+  theme: "night",
+  setTheme: () => {
+  }
+});
+function ThemeProvider({ children }) {
+  const [theme, setTheme] = useState4(() => {
+    try {
+      return localStorage.getItem("daisyui-theme") || "cupcake";
+    } catch {
+      return "cupcake";
+    }
+  });
+  const handleSetTheme = useCallback17((newTheme) => {
+    try {
+      localStorage.setItem("daisyui-theme", newTheme);
+      setTheme(newTheme);
+    } catch {
+    }
+  }, []);
+  return /* @__PURE__ */ jsx32(ThemeContext.Provider, { value: { theme, setTheme: handleSetTheme }, children });
+}
+var useTheme = () => useContext(ThemeContext);
+
+// src/DaisyUIForm.tsx
+import { withTheme } from "@rjsf/core";
+var DaisyUIForm = withTheme(Theme_default);
+var DaisyUIForm_default = DaisyUIForm;
+
+// src/DaisyUIFrameProvider.tsx
+import { useEffect as useEffect4 } from "react";
+import { jsx as jsx33 } from "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";
+    }
+  })();
+  useEffect4(() => {
+    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__ */ jsx33("div", { "data-theme": theme, className: "daisy-ui-theme", children });
+}
+var __createDaisyUIFrameProvider = (props) => {
+  return function DaisyUIFrame({ document: document2 }) {
+    return /* @__PURE__ */ jsx33(DaisyUIFrameComponent, { document: document2, ...props });
+  };
+};
+
+// src/index.ts
+var index_default = withTheme2(Theme_default);
+export {
+  DaisyUIForm_default as Form,
+  GridTemplate,
+  Templates_default as Templates,
+  Theme_default as Theme,
+  ThemeProvider,
+  Widgets_default as Widgets,
+  __createDaisyUIFrameProvider,
+  index_default as default,
+  useTheme
+};
+//# sourceMappingURL=chakra-ui.esm.js.map