@expcat/tigercat-react 2.1.2 → 2.1.4

package/dist/chunk-ACV7IV3W.mjs

@@ -0,0 +1,339 @@
+import {
+  VirtualList
+} from "./chunk-NTCVAVYZ.mjs";
+import {
+  Input
+} from "./chunk-XE34TOCS.mjs";
+import {
+  Empty
+} from "./chunk-RLUBTLOT.mjs";
+import {
+  Textarea
+} from "./chunk-ZG6WST55.mjs";
+import {
+  Avatar
+} from "./chunk-3KBFOO2E.mjs";
+import {
+  Button
+} from "./chunk-WFLXJOFU.mjs";
+import {
+  useControlledState
+} from "./chunk-UJTAHHQT.mjs";
+import {
+  useTigerConfig
+} from "./chunk-RUIFGSVN.mjs";
+
+// src/components/ChatWindow.tsx
+import React, {
+  forwardRef,
+  useCallback,
+  useImperativeHandle,
+  useEffect,
+  useMemo,
+  useRef
+} from "react";
+import {
+  classNames,
+  EMPTY_CHAT_MESSAGES,
+  getChatMessageStatusInfo,
+  buildChatMessageStatusInfo,
+  getChatStatusBarClasses,
+  formatChatTime,
+  getChatWindowLabels,
+  mergeTigerLocale,
+  resolveLocaleText,
+  canSendChatMessage,
+  shouldSendChatOnEnter,
+  isChatScrollerNearBottom,
+  planChatScroll,
+  didChatPrepend,
+  getChatItemKey,
+  getChatMessageRowClasses,
+  getChatBubbleClasses,
+  chatWindowRootClasses,
+  chatMessageListClasses,
+  chatComposerClasses,
+  CHAT_VIRTUAL_ESTIMATED_ITEM_HEIGHT
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ChatWindow = forwardRef(function ChatWindow2({
+  messages = EMPTY_CHAT_MESSAGES,
+  value,
+  defaultValue = "",
+  placeholder,
+  disabled = false,
+  maxLength,
+  emptyText,
+  sendText,
+  locale,
+  labels: labelsOverride,
+  messageListAriaLabel,
+  inputAriaLabel,
+  sendAriaLabel,
+  statusText,
+  statusVariant = "info",
+  showAvatar = true,
+  showName = true,
+  showTime = false,
+  inputType = "textarea",
+  inputRows = 3,
+  sendOnEnter = true,
+  allowShiftEnter = true,
+  allowEmpty = false,
+  clearOnSend = true,
+  virtual = false,
+  virtualItemHeight = CHAT_VIRTUAL_ESTIMATED_ITEM_HEIGHT,
+  virtualHeight = 400,
+  autoScrollToBottom = true,
+  onChange,
+  onSend,
+  renderBubble,
+  className,
+  ...props
+}, ref) {
+  const config = useTigerConfig();
+  const mergedLocale = useMemo(
+    () => mergeTigerLocale(config.locale, locale),
+    [config.locale, locale]
+  );
+  const labels = useMemo(
+    () => getChatWindowLabels(mergedLocale, labelsOverride),
+    [mergedLocale, labelsOverride]
+  );
+  const statusMap = useMemo(() => buildChatMessageStatusInfo(labels), [labels]);
+  const resolvedPlaceholder = resolveLocaleText(labels.placeholder, placeholder);
+  const resolvedEmptyText = resolveLocaleText(labels.emptyText, emptyText);
+  const resolvedSendText = resolveLocaleText(labels.sendText, sendText);
+  const listLabel = messageListAriaLabel ?? labels.messageListAriaLabel;
+  const [inputValue, setInputValue] = useControlledState({
+    value,
+    defaultValue,
+    onChange
+  });
+  const lastSentRef = useRef(null);
+  const [, setSendTick] = React.useState(0);
+  const stickToBottomRef = useRef(true);
+  const messageListRef = useRef(null);
+  const virtualListRef = useRef(null);
+  const previousScrollHeightRef = useRef(0);
+  const previousFirstIdRef = useRef(messages[0]?.id);
+  const previousLengthRef = useRef(messages.length);
+  const hasSendHandler = typeof onSend === "function";
+  const canSend = canSendChatMessage({
+    disabled,
+    allowEmpty,
+    value: inputValue,
+    sending: false,
+    hasSendHandler,
+    lastSent: lastSentRef.current
+  });
+  const wrapperClasses = useMemo(() => classNames(chatWindowRootClasses, className), [className]);
+  const resolveScroller = useCallback(() => {
+    if (virtual) return virtualListRef.current?.getScrollElement() ?? null;
+    return messageListRef.current;
+  }, [virtual]);
+  const syncStickToBottom = useCallback(() => {
+    const scroller = resolveScroller();
+    if (!scroller) return;
+    stickToBottomRef.current = isChatScrollerNearBottom(scroller);
+  }, [resolveScroller]);
+  const scrollToBottom = useCallback(() => {
+    if (!autoScrollToBottom) return;
+    requestAnimationFrame(() => {
+      const scroller = resolveScroller();
+      if (!scroller) return;
+      scroller.scrollTop = scroller.scrollHeight;
+      stickToBottomRef.current = true;
+      previousScrollHeightRef.current = scroller.scrollHeight;
+    });
+  }, [autoScrollToBottom, resolveScroller]);
+  useImperativeHandle(ref, () => ({ scrollToBottom }), [scrollToBottom]);
+  const handleValueChange = useCallback(
+    (nextValue) => {
+      if (lastSentRef.current != null && nextValue !== lastSentRef.current) {
+        lastSentRef.current = null;
+      }
+      setInputValue(nextValue);
+    },
+    [setInputValue]
+  );
+  const handleSend = useCallback(() => {
+    if (!canSendChatMessage({
+      disabled,
+      allowEmpty,
+      value: inputValue,
+      hasSendHandler,
+      lastSent: lastSentRef.current
+    })) {
+      return;
+    }
+    const payload = String(inputValue ?? "");
+    lastSentRef.current = payload;
+    setSendTick((tick) => tick + 1);
+    onSend?.(payload);
+    if (clearOnSend) setInputValue("");
+  }, [allowEmpty, clearOnSend, disabled, hasSendHandler, inputValue, onSend, setInputValue]);
+  const handleKeyDown = useCallback(
+    (event) => {
+      if (!shouldSendChatOnEnter(event.nativeEvent, {
+        sendOnEnter,
+        inputType,
+        allowShiftEnter
+      })) {
+        return;
+      }
+      event.preventDefault();
+      handleSend();
+    },
+    [allowShiftEnter, handleSend, inputType, sendOnEnter]
+  );
+  const renderBubbleBody = renderBubble;
+  const renderMessageItem = useCallback(
+    (message, index) => {
+      const isSelf = message.direction === "self";
+      const statusInfo = message.status ? getChatMessageStatusInfo(message.status, statusMap) : void 0;
+      const timeText = showTime ? formatChatTime(message.time, mergedLocale) : "";
+      return /* @__PURE__ */ jsxs(
+        "div",
+        {
+          className: getChatMessageRowClasses(isSelf),
+          "data-tiger-chat-message": true,
+          children: [
+            showAvatar && message.user ? /* @__PURE__ */ jsx(
+              Avatar,
+              {
+                size: "sm",
+                src: message.user.avatar,
+                text: message.user.name,
+                className: "flex-shrink-0",
+                "aria-hidden": Boolean(showName && message.user.name)
+              }
+            ) : null,
+            /* @__PURE__ */ jsxs("div", { className: classNames("flex flex-col max-w-[75%]", isSelf && "items-end"), children: [
+              showName && message.user?.name && /* @__PURE__ */ jsx(
+                "div",
+                {
+                  className: classNames(
+                    "text-xs mb-1 text-[var(--tiger-text-muted,#6b7280)]",
+                    isSelf && "text-end"
+                  ),
+                  children: message.user.name
+                }
+              ),
+              /* @__PURE__ */ jsx("div", { className: getChatBubbleClasses(isSelf), "data-tiger-chat-bubble": true, children: renderBubbleBody?.(message, index) ?? message.content }),
+              statusInfo && /* @__PURE__ */ jsx("div", { className: classNames("text-xs mt-1", statusInfo.className), children: message.statusText || statusInfo.text }),
+              timeText ? /* @__PURE__ */ jsx("div", { className: "text-xs mt-1 text-[var(--tiger-text-muted,#6b7280)]", children: timeText }) : null
+            ] })
+          ]
+        },
+        message.id ?? index
+      );
+    },
+    [mergedLocale, renderBubbleBody, showAvatar, showName, showTime, statusMap]
+  );
+  const lastContent = messages[messages.length - 1]?.content;
+  const firstId = messages[0]?.id;
+  useEffect(() => {
+    const raf = requestAnimationFrame(() => {
+      const scroller = resolveScroller();
+      if (!scroller) return;
+      const prepended = didChatPrepend(
+        previousFirstIdRef.current,
+        firstId,
+        previousLengthRef.current,
+        messages.length
+      );
+      const plan = planChatScroll({
+        stickToBottom: stickToBottomRef.current,
+        autoScrollToBottom,
+        prepended,
+        previousScrollHeight: previousScrollHeightRef.current,
+        nextScrollHeight: scroller.scrollHeight
+      });
+      if (plan.scrollTop != null) {
+        scroller.scrollTop = plan.scrollTop;
+        stickToBottomRef.current = true;
+      } else if (plan.compensate) {
+        scroller.scrollTop += plan.compensate;
+      }
+      previousScrollHeightRef.current = scroller.scrollHeight;
+      previousFirstIdRef.current = firstId;
+      previousLengthRef.current = messages.length;
+    });
+    return () => cancelAnimationFrame(raf);
+  }, [autoScrollToBottom, firstId, lastContent, messages.length, resolveScroller]);
+  const listA11y = {
+    role: "log",
+    "aria-live": "polite",
+    "aria-relevant": "additions text",
+    "aria-label": listLabel
+  };
+  return /* @__PURE__ */ jsxs("div", { className: wrapperClasses, "data-tiger-chat-window": true, ...props, children: [
+    virtual && messages.length > 0 ? /* @__PURE__ */ jsx(
+      VirtualList,
+      {
+        ref: virtualListRef,
+        className: chatMessageListClasses,
+        itemCount: messages.length,
+        estimatedItemHeight: virtualItemHeight,
+        height: virtualHeight,
+        getItemKey: (index) => getChatItemKey(messages, index),
+        onScroll: syncStickToBottom,
+        renderItem: ({ index }) => renderMessageItem(messages[index], index),
+        ...listA11y
+      }
+    ) : /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: messageListRef,
+        className: chatMessageListClasses,
+        ...listA11y,
+        onScroll: syncStickToBottom,
+        children: messages.length === 0 ? /* @__PURE__ */ jsx("div", { className: "h-full flex items-center justify-center py-8", children: /* @__PURE__ */ jsx(Empty, { description: resolvedEmptyText }) }) : messages.map(renderMessageItem)
+      }
+    ),
+    statusText ? /* @__PURE__ */ jsx("div", { className: getChatStatusBarClasses(statusVariant), "aria-live": "polite", children: statusText }) : null,
+    /* @__PURE__ */ jsxs("div", { className: chatComposerClasses, children: [
+      /* @__PURE__ */ jsx("div", { className: "flex-1", children: inputType === "input" ? /* @__PURE__ */ jsx(
+        Input,
+        {
+          value: inputValue,
+          placeholder: resolvedPlaceholder,
+          disabled,
+          maxLength,
+          "aria-label": inputAriaLabel ?? resolvedPlaceholder,
+          onChange: (event) => handleValueChange(event.currentTarget.value),
+          onKeyDown: handleKeyDown
+        }
+      ) : /* @__PURE__ */ jsx(
+        Textarea,
+        {
+          value: inputValue,
+          placeholder: resolvedPlaceholder,
+          disabled,
+          maxLength,
+          rows: inputRows,
+          "aria-label": inputAriaLabel ?? resolvedPlaceholder,
+          onChange: (event) => handleValueChange(event.currentTarget.value),
+          onKeyDown: handleKeyDown
+        }
+      ) }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          disabled: !canSend,
+          onClick: handleSend,
+          "aria-label": sendAriaLabel ?? resolvedSendText,
+          children: resolvedSendText
+        }
+      )
+    ] })
+  ] });
+});
+ChatWindow.displayName = "ChatWindow";
+var ChatWindow_default = ChatWindow;
+
+export {
+  ChatWindow,
+  ChatWindow_default
+};

package/dist/chunk-B2IFWWM5.mjs

@@ -0,0 +1,352 @@
+import {
+  useFormItemControlContext
+} from "./chunk-F6T3OLTQ.mjs";
+import {
+  useControlledState
+} from "./chunk-UJTAHHQT.mjs";
+import {
+  useTigerConfig
+} from "./chunk-RUIFGSVN.mjs";
+
+// src/components/CronEditor.tsx
+import { forwardRef, useEffect, useId, useMemo, useRef, useState } from "react";
+import {
+  applyCronFieldMode,
+  buildCronFieldValueFromDraft,
+  classNames,
+  cronEditorBaseClasses,
+  cronEditorErrorClasses,
+  cronEditorFieldClasses,
+  cronEditorFieldsClasses,
+  cronEditorLabelClasses,
+  cronFieldMetas,
+  cronFieldModes,
+  formatCronControlLabel,
+  getCronEditorControlClasses,
+  getCronEditorLabels,
+  getCronExpressionIssue,
+  getCronFieldIssue,
+  getCronFieldValue,
+  getCronModeLabels,
+  getDefaultCronPresets,
+  isCronExpressionEmpty,
+  isCronFieldCountValid,
+  markFormItemGroupControl,
+  mergeAriaDescribedBy,
+  mergeTigerLocale,
+  parseOptionalInt,
+  seedCronFieldDraft,
+  updateCronExpressionField,
+  validateCronExpressionWithLabels
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var CronEditorInner = forwardRef(function CronEditor({
+  value,
+  defaultValue,
+  disabled = false,
+  readonly = false,
+  size = "md",
+  presets,
+  ariaLabel,
+  locale,
+  labels: labelsOverride,
+  className,
+  name,
+  id,
+  status: statusProp,
+  onChange,
+  onValidate,
+  onBlur,
+  style
+}, ref) {
+  const config = useTigerConfig();
+  const formItemControl = useFormItemControlContext();
+  const mergedLocale = useMemo(
+    () => mergeTigerLocale(config.locale, locale),
+    [config.locale, locale]
+  );
+  const labels = useMemo(
+    () => getCronEditorLabels(mergedLocale, labelsOverride),
+    [mergedLocale, labelsOverride]
+  );
+  const fieldLabels = useMemo(
+    () => ({
+      minute: labels.minuteLabel,
+      hour: labels.hourLabel,
+      dayOfMonth: labels.dayOfMonthLabel,
+      month: labels.monthLabel,
+      dayOfWeek: labels.dayOfWeekLabel
+    }),
+    [labels]
+  );
+  const localizedMetas = useMemo(
+    () => cronFieldMetas.map((meta) => ({ ...meta, label: fieldLabels[meta.key] })),
+    [fieldLabels]
+  );
+  const resolvedPresets = useMemo(
+    () => presets === void 0 ? getDefaultCronPresets(labels) : presets,
+    [labels, presets]
+  );
+  const modeLabels = useMemo(() => getCronModeLabels(labels), [labels]);
+  const effectiveDisabled = Boolean(disabled || formItemControl?.disabled);
+  const inactive = effectiveDisabled || readonly;
+  const status = statusProp ?? formItemControl?.status ?? "default";
+  const effectiveId = id ?? formItemControl?.id;
+  const effectiveName = name ?? formItemControl?.name;
+  const describedBy = mergeAriaDescribedBy(formItemControl?.describedBy, void 0);
+  const labelledby = formItemControl?.labelId;
+  const parsedValue = value !== void 0 ? value : formItemControl?.value;
+  const [expression, setExpression] = useControlledState({
+    value: value !== void 0 || formItemControl?.value !== void 0 ? parsedValue : void 0,
+    defaultValue: defaultValue ?? "",
+    onChange: (next, validation2) => {
+      onChange?.(next, validation2);
+      onValidate?.(validation2);
+      formItemControl?.onChange?.(next);
+    }
+  });
+  const currentExpression = expression ?? "";
+  const validation = useMemo(
+    () => validateCronExpressionWithLabels(currentExpression, labels, fieldLabels),
+    [currentExpression, labels, fieldLabels]
+  );
+  const fieldsReady = isCronFieldCountValid(currentExpression);
+  const instanceId = useId();
+  const errorId = `${instanceId}-error`;
+  const stickyModes = useRef({});
+  const [drafts, setDrafts] = useState(
+    () => seedAllDrafts(currentExpression, stickyModes.current)
+  );
+  useEffect(() => {
+    setDrafts(seedAllDrafts(currentExpression, stickyModes.current));
+  }, [currentExpression]);
+  function commit(nextValue) {
+    const nextValidation = validateCronExpressionWithLabels(nextValue, labels, fieldLabels);
+    setExpression(nextValue, nextValidation);
+  }
+  function handleRawExpressionChange(nextValue) {
+    stickyModes.current = {};
+    const nextValidation = validateCronExpressionWithLabels(nextValue, labels, fieldLabels);
+    setExpression(nextValue, nextValidation);
+  }
+  function writeField(meta, draft) {
+    const raw = buildCronFieldValueFromDraft(draft, meta);
+    if (isCronExpressionEmpty(currentExpression)) {
+      const parts = ["*", "*", "*", "*", "*"];
+      const index = cronFieldMetas.findIndex((item) => item.key === meta.key);
+      parts[index] = raw;
+      commit(parts.join(" "));
+      return;
+    }
+    const updated = updateCronExpressionField(currentExpression, meta.key, raw);
+    if (updated == null) return;
+    commit(updated);
+  }
+  function handleModeChange(meta, mode) {
+    stickyModes.current[meta.key] = mode;
+    const next = applyCronFieldMode(drafts[meta.key], mode, meta);
+    setDrafts((prev) => ({ ...prev, [meta.key]: next }));
+    writeField(meta, next);
+  }
+  function patchDraft(meta, patch, commitNow) {
+    const next = { ...drafts[meta.key], ...patch };
+    setDrafts((prev) => ({ ...prev, [meta.key]: next }));
+    if (commitNow) writeField(meta, next);
+  }
+  function handleBlur(event) {
+    const next = event.relatedTarget;
+    const root = event.currentTarget.closest("[data-tiger-croneditor]");
+    if (root && next && root.contains(next)) return;
+    formItemControl?.onBlur?.();
+    onBlur?.(event);
+  }
+  function renderFieldControl(meta, draft, invalid) {
+    if (draft.mode === "any") return null;
+    if (draft.mode === "every") {
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          inputMode: "numeric",
+          className: getCronEditorControlClasses(size, invalid),
+          value: draft.stepText,
+          disabled: inactive || !fieldsReady,
+          "aria-label": formatCronControlLabel(labels.stepAriaLabel, meta.label),
+          onChange: (event) => {
+            const text = event.target.value;
+            patchDraft(meta, { stepText: text, mode: "every" }, parseOptionalInt(text) != null);
+          }
+        }
+      );
+    }
+    if (draft.mode === "specific") {
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          inputMode: "numeric",
+          className: getCronEditorControlClasses(size, invalid),
+          value: draft.valueText,
+          disabled: inactive || !fieldsReady,
+          "aria-label": formatCronControlLabel(labels.valueAriaLabel, meta.label),
+          onChange: (event) => {
+            const text = event.target.value;
+            patchDraft(meta, { valueText: text, mode: "specific" }, parseOptionalInt(text) != null);
+          }
+        }
+      );
+    }
+    if (draft.mode === "range") {
+      return /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-1", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            inputMode: "numeric",
+            className: getCronEditorControlClasses(size, invalid),
+            value: draft.startText,
+            disabled: inactive || !fieldsReady,
+            "aria-label": formatCronControlLabel(labels.rangeStartAriaLabel, meta.label),
+            onChange: (event) => {
+              const text = event.target.value;
+              patchDraft(
+                meta,
+                { startText: text, mode: "range" },
+                parseOptionalInt(text) != null && parseOptionalInt(draft.endText) != null
+              );
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            inputMode: "numeric",
+            className: getCronEditorControlClasses(size, invalid),
+            value: draft.endText,
+            disabled: inactive || !fieldsReady,
+            "aria-label": formatCronControlLabel(labels.rangeEndAriaLabel, meta.label),
+            onChange: (event) => {
+              const text = event.target.value;
+              patchDraft(
+                meta,
+                { endText: text, mode: "range" },
+                parseOptionalInt(draft.startText) != null && parseOptionalInt(text) != null
+              );
+            }
+          }
+        )
+      ] });
+    }
+    return /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "text",
+        className: getCronEditorControlClasses(size, invalid),
+        value: draft.raw,
+        disabled: inactive || !fieldsReady,
+        "aria-label": formatCronControlLabel(labels.customValueAriaLabel, meta.label),
+        onChange: (event) => patchDraft(meta, { raw: event.target.value, mode: "custom" }, true)
+      }
+    );
+  }
+  const expressionIssue = getCronExpressionIssue(validation);
+  const expressionInvalid = Boolean(expressionIssue) && !isCronExpressionEmpty(currentExpression);
+  const groupName = ariaLabel ?? labels.ariaLabel;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classNames(cronEditorBaseClasses, className),
+      style,
+      role: "group",
+      "data-tiger-croneditor": "",
+      "aria-label": labelledby ? void 0 : groupName,
+      "aria-labelledby": labelledby,
+      "aria-describedby": describedBy,
+      "aria-invalid": status === "error" || expressionInvalid ? true : void 0,
+      onBlur: handleBlur,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2 sm:flex-row", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              ref,
+              type: "text",
+              id: effectiveId,
+              name: effectiveName,
+              className: classNames(getCronEditorControlClasses(size, expressionInvalid), "flex-1"),
+              value: currentExpression,
+              disabled: effectiveDisabled,
+              readOnly: readonly,
+              "aria-label": labels.expressionAriaLabel,
+              "aria-invalid": expressionInvalid || void 0,
+              "aria-describedby": expressionIssue ? errorId : describedBy,
+              onChange: (event) => handleRawExpressionChange(event.target.value)
+            }
+          ),
+          resolvedPresets.length > 0 && /* @__PURE__ */ jsxs(
+            "select",
+            {
+              className: getCronEditorControlClasses(size),
+              value: resolvedPresets.some((preset) => preset.value === currentExpression) ? currentExpression : "",
+              disabled: inactive,
+              "aria-label": labels.presetAriaLabel,
+              onChange: (event) => {
+                if (event.target.value) {
+                  stickyModes.current = {};
+                  commit(event.target.value);
+                }
+              },
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: labels.presetPlaceholder }),
+                resolvedPresets.map((preset) => /* @__PURE__ */ jsx("option", { value: preset.value, children: preset.label }, preset.value))
+              ]
+            }
+          )
+        ] }),
+        expressionIssue ? /* @__PURE__ */ jsx("div", { id: errorId, className: cronEditorErrorClasses, role: "alert", children: expressionIssue.message }) : null,
+        /* @__PURE__ */ jsx("div", { className: cronEditorFieldsClasses, children: localizedMetas.map((meta) => {
+          const draft = drafts[meta.key];
+          const issue = getCronFieldIssue(validation, meta.key);
+          const modeId = `${instanceId}-${meta.key}-mode`;
+          const fieldErrorId = `${instanceId}-${meta.key}-error`;
+          return /* @__PURE__ */ jsxs("div", { className: cronEditorFieldClasses, children: [
+            /* @__PURE__ */ jsx("label", { className: cronEditorLabelClasses, htmlFor: modeId, children: meta.label }),
+            /* @__PURE__ */ jsx(
+              "select",
+              {
+                id: modeId,
+                className: getCronEditorControlClasses(size, Boolean(issue)),
+                value: draft.mode,
+                disabled: inactive || !fieldsReady,
+                "aria-invalid": issue ? true : void 0,
+                "aria-describedby": issue ? fieldErrorId : void 0,
+                "aria-label": formatCronControlLabel(labels.modeAriaLabel, meta.label),
+                onChange: (event) => handleModeChange(meta, event.target.value),
+                children: cronFieldModes.map((mode) => /* @__PURE__ */ jsx("option", { value: mode, children: modeLabels[mode] }, mode))
+              }
+            ),
+            renderFieldControl(meta, draft, Boolean(issue)),
+            issue ? /* @__PURE__ */ jsx("div", { id: fieldErrorId, className: cronEditorErrorClasses, children: issue.message }) : null
+          ] }, meta.key);
+        }) })
+      ]
+    }
+  );
+});
+var CronEditor2 = markFormItemGroupControl(CronEditorInner);
+function seedAllDrafts(expression, sticky) {
+  const ready = isCronFieldCountValid(expression);
+  return Object.fromEntries(
+    cronFieldMetas.map((meta) => {
+      const raw = ready ? getCronFieldValue(expression, meta.key) ?? "*" : "*";
+      return [meta.key, seedCronFieldDraft(raw, sticky[meta.key])];
+    })
+  );
+}
+var CronEditor_default = CronEditor2;
+
+export {
+  CronEditor2 as CronEditor,
+  CronEditor_default
+};