@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/{chunk-34DLDOGP.mjs → chunk-Y5E4XH6H.mjs}

@@ -1,8 +1,32 @@
-import React, { createContext, forwardRef, useState, useCallback, useImperativeHandle, useMemo, useContext } from 'react';
-import { createFormHistory, getValueByPath, validateField, getDependentFields, validateForm, pushFormHistory, undoFormHistory, redoFormHistory, canRedo, canUndo, classNames } from '@expcat/tigercat-core';
-import { jsx } from 'react/jsx-runtime';
-
 // src/components/Form.tsx
+import React, {
+  createContext,
+  useContext,
+  useState,
+  useCallback,
+  useMemo,
+  useImperativeHandle,
+  forwardRef
+} from "react";
+import {
+  classNames,
+  validateForm,
+  validateField as validateFieldUtil,
+  getValueByPath,
+  createFormErrorMap,
+  getDependentFields,
+  createFormConditionDependencies,
+  resolveConditionalFormRules,
+  resolveFormFieldConditionState,
+  createFormValidationDebouncer,
+  createFormHistory,
+  pushFormHistory,
+  undoFormHistory,
+  redoFormHistory,
+  canUndo,
+  canRedo
+} from "@expcat/tigercat-core";
+import { jsx } from "react/jsx-runtime";
 var FormContext = createContext(null);
 var useFormContext = () => {
   const context = useContext(FormContext);
@@ -26,6 +50,8 @@ var Form = forwardRef(
     onChange,
     className,
     fieldDependencies,
+    conditions,
+    validateDebounce = 0,
     undoable = false,
     maxHistorySize = 50,
     ...props
@@ -33,11 +59,21 @@ var Form = forwardRef(
     const [errors, setErrors] = useState([]);
     const [formValues, setFormValues] = useState(model);
     const fieldRulesRef = React.useRef({});
+    const fieldConditionsRef = React.useRef({});
     const formValuesRef = React.useRef(model);
+    const validationDebouncerRef = React.useRef(
+      createFormValidationDebouncer({ delay: validateDebounce })
+    );
+    const errorsByField = useMemo(() => createFormErrorMap(errors), [errors]);
     const [historyState, setHistoryState] = useState(() => createFormHistory(model, maxHistorySize));
     React.useEffect(() => {
       setFormValues(model);
     }, [model]);
+    React.useEffect(() => {
+      validationDebouncerRef.current.cancel();
+      validationDebouncerRef.current = createFormValidationDebouncer({ delay: validateDebounce });
+      return () => validationDebouncerRef.current.cancel();
+    }, [validateDebounce]);
     formValuesRef.current = model;
     const registerFieldRules = useCallback(
       (fieldName, nextRules) => {
@@ -52,18 +88,70 @@ var Form = forwardRef(
       },
       []
     );
+    const registerFieldCondition = useCallback(
+      (fieldName, condition) => {
+        if (!fieldName) {
+          return;
+        }
+        if (!condition) {
+          delete fieldConditionsRef.current[fieldName];
+          return;
+        }
+        fieldConditionsRef.current[fieldName] = condition;
+      },
+      []
+    );
+    const getEffectiveConditions = useCallback(() => {
+      const merged = { ...conditions ?? {}, ...fieldConditionsRef.current };
+      return Object.keys(merged).length > 0 ? merged : void 0;
+    }, [conditions]);
+    const getMergedFieldCondition = useCallback(
+      (fieldName, conditionOverride) => {
+        const base = getEffectiveConditions()?.[fieldName];
+        return base || conditionOverride ? { ...base ?? {}, ...conditionOverride ?? {} } : void 0;
+      },
+      [getEffectiveConditions]
+    );
+    const getFieldConditionState = useCallback(
+      (fieldName, conditionOverride) => {
+        return resolveFormFieldConditionState(
+          formValuesRef.current,
+          getMergedFieldCondition(fieldName, conditionOverride)
+        );
+      },
+      [getMergedFieldCondition]
+    );
     const getEffectiveRules = useCallback(() => {
       const fromForm = rules ?? {};
       const fromItems = fieldRulesRef.current;
       const merged = { ...fromForm, ...fromItems };
-      return Object.keys(merged).length > 0 ? merged : void 0;
-    }, [rules]);
+      const nextRules = Object.keys(merged).length > 0 ? merged : void 0;
+      return resolveConditionalFormRules(formValuesRef.current, nextRules, getEffectiveConditions());
+    }, [rules, getEffectiveConditions]);
     const resolveFieldRules = useCallback(
       (fieldName, rulesOverride) => {
-        return rulesOverride ?? fieldRulesRef.current[fieldName] ?? rules?.[fieldName];
+        const fieldRules = rulesOverride ?? fieldRulesRef.current[fieldName] ?? rules?.[fieldName];
+        const resolved = resolveConditionalFormRules(
+          formValuesRef.current,
+          fieldRules ? { [fieldName]: fieldRules } : void 0,
+          getEffectiveConditions()
+        );
+        return resolved?.[fieldName];
       },
-      [rules]
+      [rules, getEffectiveConditions]
     );
+    const getDependencyMap = useCallback(() => {
+      const conditionDependencies = createFormConditionDependencies(getEffectiveConditions());
+      if (!fieldDependencies && conditionDependencies.size === 0) {
+        return void 0;
+      }
+      const merged = new Map(fieldDependencies ?? []);
+      for (const [fieldName, dependencies] of conditionDependencies.entries()) {
+        const current = merged.get(fieldName) ?? [];
+        merged.set(fieldName, Array.from(/* @__PURE__ */ new Set([...current, ...dependencies])));
+      }
+      return merged;
+    }, [fieldDependencies, getEffectiveConditions]);
     const runFieldValidation = useCallback(
       async (fieldName, rulesOverride, trigger) => {
         const fieldRules = resolveFieldRules(fieldName, rulesOverride);
@@ -72,12 +160,18 @@ var Form = forwardRef(
         }
         const currentValues = formValuesRef.current;
         const value = getValueByPath(currentValues, fieldName);
-        return validateField(fieldName, value, fieldRules, currentValues, trigger);
+        return validateFieldUtil(fieldName, value, fieldRules, currentValues, trigger);
       },
       [resolveFieldRules]
     );
-    const validateField$1 = useCallback(
+    const validateFieldNow = useCallback(
       async (fieldName, rulesOverride, trigger) => {
+        const conditionState = getFieldConditionState(fieldName);
+        if (!conditionState.shown || conditionState.disabled) {
+          setErrors((prevErrors) => prevErrors.filter((error) => error.field !== fieldName));
+          onValidate?.(fieldName, true, null);
+          return;
+        }
         const fieldRules = resolveFieldRules(fieldName, rulesOverride);
         if (fieldRules) {
           const error = await runFieldValidation(fieldName, rulesOverride, trigger);
@@ -94,16 +188,31 @@ var Form = forwardRef(
           });
           onValidate?.(fieldName, !error, error);
         }
-        if (fieldDependencies) {
-          const dependents = getDependentFields(fieldName, fieldDependencies);
+        const dependencyMap = getDependencyMap();
+        if (dependencyMap) {
+          const dependents = getDependentFields(fieldName, dependencyMap);
           for (const dep of dependents) {
-            await validateField$1(dep);
+            await validateFieldNow(dep);
           }
         }
       },
-      [resolveFieldRules, runFieldValidation, onValidate, fieldDependencies]
+      [resolveFieldRules, runFieldValidation, onValidate, getFieldConditionState, getDependencyMap]
+    );
+    const validateField = useCallback(
+      async (fieldName, rulesOverride, trigger) => {
+        if (trigger === "change" && validateDebounce > 0) {
+          return validationDebouncerRef.current.schedule(
+            fieldName,
+            () => validateFieldNow(fieldName, rulesOverride, trigger)
+          );
+        }
+        validationDebouncerRef.current.cancel(fieldName);
+        return validateFieldNow(fieldName, rulesOverride, trigger);
+      },
+      [validateDebounce, validateFieldNow]
     );
     const runValidation = useCallback(async () => {
+      validationDebouncerRef.current.cancel();
       const effectiveRules = getEffectiveRules();
       if (!effectiveRules) {
         setErrors([]);
@@ -122,6 +231,7 @@ var Form = forwardRef(
         if (!fieldNames || fieldNames.length === 0) {
           return true;
         }
+        fieldNames.forEach((fieldName) => validationDebouncerRef.current.cancel(fieldName));
         const nextErrors = [];
         const fieldSet = new Set(fieldNames);
         for (const fieldName of fieldNames) {
@@ -146,10 +256,12 @@ var Form = forwardRef(
     );
     const clearValidate = useCallback((fieldNames) => {
       if (!fieldNames) {
+        validationDebouncerRef.current.cancel();
         setErrors([]);
         return;
       }
       const fields = Array.isArray(fieldNames) ? fieldNames : [fieldNames];
+      fields.forEach((fieldName) => validationDebouncerRef.current.cancel(fieldName));
       setErrors((prevErrors) => prevErrors.filter((error) => !fields.includes(error.field)));
     }, []);
     const resetFields = useCallback(() => {
@@ -257,7 +369,7 @@ var Form = forwardRef(
       () => ({
         validate,
         validateFields,
-        validateField: validateField$1,
+        validateField,
         clearValidate,
         resetFields,
         addField,
@@ -271,7 +383,7 @@ var Form = forwardRef(
       [
         validate,
         validateFields,
-        validateField$1,
+        validateField,
         clearValidate,
         resetFields,
         addField,
@@ -295,8 +407,11 @@ var Form = forwardRef(
         disabled,
         loading,
         errors,
+        errorsByField,
         registerFieldRules,
-        validateField: validateField$1,
+        registerFieldCondition,
+        getFieldConditionState,
+        validateField,
         clearValidate,
         updateValue
       }),
@@ -312,8 +427,11 @@ var Form = forwardRef(
         disabled,
         loading,
         errors,
+        errorsByField,
         registerFieldRules,
-        validateField$1,
+        registerFieldCondition,
+        getFieldConditionState,
+        validateField,
         clearValidate,
         updateValue
       ]
@@ -330,4 +448,7 @@ var Form = forwardRef(
 );
 Form.displayName = "TigerForm";
 
-export { Form, useFormContext };
+export {
+  useFormContext,
+  Form
+};

package/dist/chunk-Y6557RWE.mjs

@@ -1,8 +1,12 @@
-import { createContext, useContext, useState, useMemo, useCallback } from 'react';
-import { normalizeActiveKeys, togglePanelKey, classNames, getCollapseContainerClasses } from '@expcat/tigercat-core';
-import { jsx } from 'react/jsx-runtime';
-
 // src/components/Collapse.tsx
+import { createContext, useContext, useState, useMemo, useCallback } from "react";
+import {
+  classNames,
+  getCollapseContainerClasses,
+  normalizeActiveKeys,
+  togglePanelKey
+} from "@expcat/tigercat-core";
+import { jsx } from "react/jsx-runtime";
 var CollapseContext = createContext(null);
 function useCollapseContext() {
   return useContext(CollapseContext);
@@ -59,4 +63,8 @@ var Collapse = ({
 };
 var Collapse_default = Collapse;
 
-export { Collapse, Collapse_default, useCollapseContext };
+export {
+  useCollapseContext,
+  Collapse,
+  Collapse_default
+};

package/dist/chunk-YID7J6ZK.js

@@ -1,10 +1,22 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var chunkHQ3QOT7H_js = require('./chunk-HQ3QOT7H.js');
-var react = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
+var _chunkHQ3QOT7Hjs = require('./chunk-HQ3QOT7H.js');
 
+// src/components/Result.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
 var Result = ({
   status = "info",
   title,
@@ -15,23 +27,25 @@ var Result = ({
   children,
   ...props
 }) => {
-  const colors = react.useMemo(() => tigercatCore.getResultColorScheme(status), [status]);
-  const iconPath = react.useMemo(() => tigercatCore.getResultIconPath(status), [status]);
-  const httpLabel = react.useMemo(() => tigercatCore.getResultHttpLabel(status), [status]);
-  const wrapperClasses = react.useMemo(() => tigercatCore.classNames(tigercatCore.resultBaseClasses, className), [className]);
-  const iconContainerCls = react.useMemo(
-    () => tigercatCore.classNames(tigercatCore.resultIconContainerBaseClasses, colors.iconBg),
+  const colors = _react.useMemo.call(void 0, () => _tigercatcore.getResultColorScheme.call(void 0, status), [status]);
+  const iconPath = _react.useMemo.call(void 0, () => _tigercatcore.getResultIconPath.call(void 0, status), [status]);
+  const httpLabel = _react.useMemo.call(void 0, () => _tigercatcore.getResultHttpLabel.call(void 0, status), [status]);
+  const wrapperClasses = _react.useMemo.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.resultBaseClasses, className), [className]);
+  const iconContainerCls = _react.useMemo.call(void 0, 
+    () => _tigercatcore.classNames.call(void 0, _tigercatcore.resultIconContainerBaseClasses, colors.iconBg),
     [colors]
   );
-  const iconSvgCls = react.useMemo(() => tigercatCore.classNames(tigercatCore.resultIconClasses, colors.iconColor), [colors]);
-  const titleCls = react.useMemo(() => tigercatCore.classNames(tigercatCore.resultTitleClasses, colors.titleColor), [colors]);
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: wrapperClasses, role: "status", ...props, children: [
-    /* @__PURE__ */ jsxRuntime.jsx("div", { className: iconContainerCls, children: icon !== void 0 ? icon : httpLabel ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: tigercatCore.classNames("text-5xl font-bold", colors.iconColor), children: httpLabel }) : /* @__PURE__ */ jsxRuntime.jsx(chunkHQ3QOT7H_js.StatusIcon, { path: iconPath, className: iconSvgCls }) }),
-    title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: titleCls, children: title }),
-    subTitle && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.resultSubTitleClasses, children: subTitle }),
-    extra && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.resultExtraClasses, children: extra }),
-    children && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mt-6 w-full", children })
+  const iconSvgCls = _react.useMemo.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.resultIconClasses, colors.iconColor), [colors]);
+  const titleCls = _react.useMemo.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.resultTitleClasses, colors.titleColor), [colors]);
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: wrapperClasses, role: "status", ...props, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: iconContainerCls, children: icon !== void 0 ? icon : httpLabel ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: _tigercatcore.classNames.call(void 0, "text-5xl font-bold", colors.iconColor), children: httpLabel }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkHQ3QOT7Hjs.StatusIcon, { path: iconPath, className: iconSvgCls }) }),
+    title && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: titleCls, children: title }),
+    subTitle && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.resultSubTitleClasses, children: subTitle }),
+    extra && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.resultExtraClasses, children: extra }),
+    children && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "mt-6 w-full", children })
   ] });
 };
 
+
+
 exports.Result = Result;

package/dist/chunk-YMKA4L3Z.js

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/ButtonGroup.tsx
+var _react = require('react');
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var ButtonGroupContext = _react.createContext.call(void 0, null);
+function useButtonGroupContext() {
+  return _react.useContext.call(void 0, ButtonGroupContext);
+}
+var ButtonGroup = ({
+  size,
+  vertical = false,
+  className,
+  children,
+  ...rest
+}) => {
+  const contextValue = _react.useMemo.call(void 0, () => ({ size }), [size]);
+  const groupClasses = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getButtonGroupClasses.call(void 0, vertical, className),
+    [vertical, className]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ButtonGroupContext.Provider, { value: contextValue, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { ...rest, className: groupClasses, role: "group", children }) });
+};
+
+
+
+
+
+exports.ButtonGroupContext = ButtonGroupContext; exports.useButtonGroupContext = useButtonGroupContext; exports.ButtonGroup = ButtonGroup;

package/dist/chunk-YOAYDEWW.mjs

@@ -0,0 +1,236 @@
+import {
+  useControlledState
+} from "./chunk-UQMPEMY7.mjs";
+
+// src/components/MarkdownEditor.tsx
+import { useCallback, useMemo, useRef } from "react";
+import {
+  applyMarkdownToolbarAction,
+  classNames,
+  defaultMarkdownToolbar,
+  findMarkdownHotkeyMatch,
+  getMarkdownBodyClasses,
+  getMarkdownContainerClasses,
+  getMarkdownToolbarButtonClasses,
+  isMarkdownToolbarSeparator,
+  markdownEditorEmptyPreviewClasses,
+  markdownEditorPreviewClasses,
+  markdownEditorSplitDividerClasses,
+  markdownEditorTextareaClasses,
+  markdownEditorToolbarClasses,
+  markdownEditorToolbarGroupClasses,
+  markdownEditorToolbarSeparatorClasses,
+  markdownModeLabels,
+  parseMarkdownHeight,
+  renderMarkdownToHtml
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var modes = ["edit", "split", "preview"];
+function scheduleSelectionRestore(textarea, result) {
+  const schedule = typeof requestAnimationFrame === "function" ? requestAnimationFrame : (callback) => window.setTimeout(callback, 0);
+  schedule(() => {
+    textarea.selectionStart = result.selectionStart;
+    textarea.selectionEnd = result.selectionEnd;
+    textarea.focus();
+  });
+}
+var MarkdownEditor = ({
+  value,
+  defaultValue = "",
+  placeholder,
+  mode,
+  defaultMode = "split",
+  toolbar,
+  showModeSwitch = true,
+  height = 360,
+  readOnly = false,
+  disabled = false,
+  renderer,
+  onChange,
+  onModeChange,
+  className,
+  style,
+  ...restProps
+}) => {
+  const textareaRef = useRef(null);
+  const [currentValue, setInternalValue, isValueControlled] = useControlledState(
+    value,
+    defaultValue
+  );
+  const [currentMode, setInternalMode, isModeControlled] = useControlledState(mode, defaultMode);
+  const toolbarItems = useMemo(
+    () => toolbar === false ? [] : toolbar ?? defaultMarkdownToolbar,
+    [toolbar]
+  );
+  const previewHtml = useMemo(
+    () => renderMarkdownToHtml(currentValue, renderer),
+    [currentValue, renderer]
+  );
+  const containerStyle = useMemo(() => {
+    const parsedHeight = parseMarkdownHeight(height);
+    return { ...parsedHeight ? { height: parsedHeight } : {}, ...style };
+  }, [height, style]);
+  const commitValue = useCallback(
+    (nextValue) => {
+      if (!isValueControlled) setInternalValue(nextValue);
+      onChange?.(nextValue);
+    },
+    [isValueControlled, onChange, setInternalValue]
+  );
+  const commitMode = useCallback(
+    (nextMode) => {
+      if (!isModeControlled) setInternalMode(nextMode);
+      onModeChange?.(nextMode);
+    },
+    [isModeControlled, onModeChange, setInternalMode]
+  );
+  const applyToolbarButton = useCallback(
+    (button) => {
+      if (readOnly || disabled) return;
+      const textarea = textareaRef.current;
+      const selection = {
+        value: currentValue,
+        selectionStart: textarea?.selectionStart ?? currentValue.length,
+        selectionEnd: textarea?.selectionEnd ?? currentValue.length
+      };
+      const result = applyMarkdownToolbarAction(button, selection);
+      commitValue(result.value);
+      if (textarea) scheduleSelectionRestore(textarea, result);
+    },
+    [commitValue, currentValue, disabled, readOnly]
+  );
+  const handleKeyDown = useCallback(
+    (event) => {
+      if (event.key === "Tab") {
+        event.preventDefault();
+        const textarea = event.currentTarget;
+        const before = textarea.value.slice(0, textarea.selectionStart);
+        const after = textarea.value.slice(textarea.selectionEnd);
+        const result = {
+          value: `${before}  ${after}`,
+          selectionStart: textarea.selectionStart + 2,
+          selectionEnd: textarea.selectionStart + 2
+        };
+        commitValue(result.value);
+        scheduleSelectionRestore(textarea, result);
+        return;
+      }
+      const match = findMarkdownHotkeyMatch(toolbarItems, event.nativeEvent);
+      if (match) {
+        event.preventDefault();
+        applyToolbarButton(match);
+      }
+    },
+    [applyToolbarButton, commitValue, toolbarItems]
+  );
+  const showFormattingToolbar = toolbar !== false;
+  const showTopbar = showFormattingToolbar || showModeSwitch;
+  const showEditor = currentMode === "edit" || currentMode === "split";
+  const showPreview = currentMode === "preview" || currentMode === "split";
+  const previewNode = /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: classNames(
+        markdownEditorPreviewClasses,
+        currentMode === "split" ? markdownEditorSplitDividerClasses : void 0,
+        !currentValue ? markdownEditorEmptyPreviewClasses : void 0
+      ),
+      role: "region",
+      "aria-label": "Markdown preview",
+      dangerouslySetInnerHTML: { __html: currentValue ? previewHtml : placeholder || "" }
+    }
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: getMarkdownContainerClasses(disabled, className),
+      style: containerStyle,
+      "data-mode": currentMode,
+      ...restProps,
+      children: [
+        showTopbar && /* @__PURE__ */ jsxs("div", { className: markdownEditorToolbarClasses, children: [
+          showFormattingToolbar ? /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: markdownEditorToolbarGroupClasses,
+              role: "toolbar",
+              "aria-label": "Markdown formatting",
+              children: toolbarItems.map((item, index) => {
+                if (isMarkdownToolbarSeparator(item)) {
+                  return /* @__PURE__ */ jsx(
+                    "div",
+                    {
+                      className: markdownEditorToolbarSeparatorClasses,
+                      role: "separator",
+                      "aria-orientation": "vertical"
+                    },
+                    `separator-${index}`
+                  );
+                }
+                return /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    className: getMarkdownToolbarButtonClasses(false),
+                    title: item.tooltip ?? item.label,
+                    "aria-label": item.tooltip ?? item.label,
+                    disabled: disabled || readOnly,
+                    onClick: () => applyToolbarButton(item),
+                    children: item.icon ? /* @__PURE__ */ jsx("span", { dangerouslySetInnerHTML: { __html: item.icon } }) : item.label
+                  },
+                  item.name
+                );
+              })
+            }
+          ) : /* @__PURE__ */ jsx("span", {}),
+          showModeSwitch && /* @__PURE__ */ jsx(
+            "div",
+            {
+              className: markdownEditorToolbarGroupClasses,
+              role: "toolbar",
+              "aria-label": "Markdown view mode",
+              children: modes.map((item) => /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  className: getMarkdownToolbarButtonClasses(currentMode === item),
+                  "aria-label": markdownModeLabels[item],
+                  "aria-pressed": currentMode === item,
+                  disabled,
+                  onClick: () => commitMode(item),
+                  children: markdownModeLabels[item]
+                },
+                item
+              ))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: getMarkdownBodyClasses(currentMode), children: [
+          showEditor && /* @__PURE__ */ jsx(
+            "textarea",
+            {
+              ref: textareaRef,
+              className: markdownEditorTextareaClasses,
+              value: currentValue,
+              onChange: (event) => commitValue(event.target.value),
+              onKeyDown: handleKeyDown,
+              placeholder,
+              readOnly: readOnly || disabled,
+              disabled,
+              spellCheck: true,
+              "aria-label": "Markdown editor",
+              "aria-multiline": true
+            }
+          ),
+          showPreview && previewNode
+        ] })
+      ]
+    }
+  );
+};
+var MarkdownEditor_default = MarkdownEditor;
+
+export {
+  MarkdownEditor,
+  MarkdownEditor_default
+};

package/dist/chunk-YWTZALG5.js

@@ -1,9 +1,11 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/Sidebar.tsx
 
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
 
-// src/components/Sidebar.tsx
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
 var Sidebar = ({
   className,
   width = "256px",
@@ -13,16 +15,18 @@ var Sidebar = ({
   children,
   ...props
 }) => {
-  const sidebarClasses = tigercatCore.classNames(
-    tigercatCore.layoutSidebarClasses,
-    collapsed && tigercatCore.layoutSidebarCollapsedClasses,
+  const sidebarClasses = _tigercatcore.classNames.call(void 0, 
+    _tigercatcore.layoutSidebarClasses,
+    collapsed && _tigercatcore.layoutSidebarCollapsedClasses,
     className
   );
   const sidebarStyle = {
     ...style,
-    ...tigercatCore.getSidebarStyle(collapsed, width, collapsedWidth)
+    ..._tigercatcore.getSidebarStyle.call(void 0, collapsed, width, collapsedWidth)
   };
-  return /* @__PURE__ */ jsxRuntime.jsx("aside", { className: sidebarClasses, style: sidebarStyle, ...props, children });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "aside", { className: sidebarClasses, style: sidebarStyle, ...props, children });
 };
 
+
+
 exports.Sidebar = Sidebar;