@expcat/tigercat-react 2.1.2 → 2.1.3

package/dist/chunk-RTKPLZ5A.mjs

@@ -0,0 +1,545 @@
+import {
+  ImagePreview
+} from "./chunk-OYQ6HTLQ.mjs";
+import {
+  Icon
+} from "./chunk-WPRXOO6N.mjs";
+import {
+  Button
+} from "./chunk-WFLXJOFU.mjs";
+import {
+  useFormItemControlContext
+} from "./chunk-F6T3OLTQ.mjs";
+import {
+  useControlledState
+} from "./chunk-UJTAHHQT.mjs";
+import {
+  useTigerConfig
+} from "./chunk-RUIFGSVN.mjs";
+
+// src/components/Upload.tsx
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import {
+  classNames,
+  createUploadController,
+  createUploadPreviewUrlCache,
+  formatFileSize,
+  getDragAreaClasses,
+  getFileListItemClasses,
+  getPictureCardClasses,
+  getUploadLabels,
+  getUploadStatusIconClasses,
+  handleUploadDragLeave,
+  handleUploadDragOver,
+  handleUploadDrop,
+  interpolateUploadLabel,
+  isImageUploadFile,
+  mergeAriaDescribedBy,
+  mergeTigerLocale,
+  readUploadDropFiles,
+  runShakeAnimation,
+  uploadFileInputClasses,
+  uploadIconActionClasses,
+  uploadItemActionsClasses,
+  uploadListClasses,
+  uploadPictureImageWrapClasses,
+  uploadPictureListClasses,
+  uploadPictureOverlayClasses,
+  uploadProgressTrackClasses,
+  uploadProgressValueClasses
+} from "@expcat/tigercat-core";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function UploadStatusIcon({
+  status,
+  labels,
+  size
+}) {
+  if (status === "success") {
+    return /* @__PURE__ */ jsx(
+      Icon,
+      {
+        name: "success",
+        className: getUploadStatusIconClasses("success", size),
+        role: "img",
+        "aria-label": labels.successAriaLabel
+      }
+    );
+  }
+  if (status === "error") {
+    return /* @__PURE__ */ jsx(
+      Icon,
+      {
+        name: "error",
+        className: getUploadStatusIconClasses("error", size),
+        role: "img",
+        "aria-label": labels.errorAriaLabel
+      }
+    );
+  }
+  if (status === "uploading") {
+    return /* @__PURE__ */ jsx(
+      Icon,
+      {
+        name: "refresh",
+        className: getUploadStatusIconClasses("uploading", size, { spinning: true }),
+        role: "img",
+        "aria-label": labels.uploadingAriaLabel
+      }
+    );
+  }
+  return null;
+}
+var Upload = forwardRef(function Upload2({
+  accept,
+  multiple = false,
+  limit,
+  maxSize,
+  disabled = false,
+  drag = false,
+  listType = "text",
+  fileList: fileListProp,
+  defaultFileList,
+  name,
+  status: statusProp,
+  action,
+  method,
+  headers,
+  data,
+  withCredentials,
+  showFileList = true,
+  autoUpload = true,
+  queue = false,
+  maxConcurrent = 2,
+  chunkSize,
+  resumable = false,
+  customRequest,
+  onQueueChange,
+  onChunkProgress,
+  onChange,
+  onRemove,
+  onPreview,
+  onReject,
+  beforeUpload,
+  onProgress,
+  onSuccess,
+  onError,
+  onExceed,
+  locale,
+  labels: labelsOverrides,
+  children,
+  className,
+  style,
+  id,
+  onBlur,
+  ...divProps
+}, ref) {
+  const config = useTigerConfig();
+  const formItemControl = useFormItemControlContext();
+  const mergedLocale = useMemo(
+    () => mergeTigerLocale(config.locale, locale),
+    [config.locale, locale]
+  );
+  const labels = useMemo(
+    () => getUploadLabels(mergedLocale, labelsOverrides),
+    [mergedLocale, labelsOverrides]
+  );
+  const effectiveDisabled = Boolean(disabled || formItemControl?.disabled);
+  const status = statusProp ?? formItemControl?.status ?? "default";
+  const reactId = useId();
+  const triggerId = id ?? formItemControl?.id ?? `tiger-upload-${reactId}`;
+  const inputId = `${triggerId}-input`;
+  const describedBy = mergeAriaDescribedBy(
+    typeof divProps["aria-describedby"] === "string" ? divProps["aria-describedby"] : void 0,
+    formItemControl?.describedBy
+  );
+  const labelledby = typeof divProps["aria-labelledby"] === "string" ? divProps["aria-labelledby"] : formItemControl?.labelId;
+  const fieldName = name ?? formItemControl?.name;
+  const rootRef = useRef(null);
+  const inputRef = useRef(null);
+  const triggerRef = useRef(null);
+  const previewUrls = useRef(createUploadPreviewUrlCache());
+  const [isDragging, setIsDragging] = useState(false);
+  const [previewSrc, setPreviewSrc] = useState(null);
+  const [fileList, setFileList] = useControlledState({
+    value: fileListProp,
+    defaultValue: defaultFileList ?? [],
+    onChange: (nextList, file) => {
+      if (file) onChange?.(file, nextList);
+      formItemControl?.onChange?.(nextList);
+    }
+  });
+  const fileListRef = useRef(fileList);
+  fileListRef.current = fileList;
+  const callbacksRef = useRef({
+    onRemove,
+    onProgress,
+    onSuccess,
+    onError,
+    onExceed,
+    onReject,
+    onQueueChange,
+    onChunkProgress
+  });
+  callbacksRef.current = {
+    onRemove,
+    onProgress,
+    onSuccess,
+    onError,
+    onExceed,
+    onReject,
+    onQueueChange,
+    onChunkProgress
+  };
+  const configRef = useRef({
+    accept,
+    limit,
+    maxSize,
+    autoUpload,
+    queue,
+    maxConcurrent,
+    chunkSize,
+    resumable,
+    action,
+    name: fieldName,
+    method,
+    headers,
+    data,
+    withCredentials,
+    customRequest,
+    beforeUpload
+  });
+  configRef.current = {
+    accept,
+    limit,
+    maxSize,
+    autoUpload,
+    queue,
+    maxConcurrent,
+    chunkSize,
+    resumable,
+    action,
+    name: fieldName,
+    method,
+    headers,
+    data,
+    withCredentials,
+    customRequest,
+    beforeUpload
+  };
+  const controllerRef = useRef(
+    createUploadController({
+      host: {
+        getFileList: () => fileListRef.current,
+        setFileList: (list, changed) => {
+          fileListRef.current = list;
+          setFileList(list, changed);
+        }
+      },
+      getConfig: () => ({
+        ...configRef.current,
+        autoUpload: configRef.current.autoUpload,
+        queue: configRef.current.queue,
+        maxConcurrent: configRef.current.maxConcurrent ?? 2,
+        resumable: Boolean(configRef.current.resumable)
+      }),
+      callbacks: {
+        onRemove: (file, list) => callbacksRef.current.onRemove?.(file, list),
+        onProgress: (progress, file) => callbacksRef.current.onProgress?.(progress, file),
+        onSuccess: (response, file) => callbacksRef.current.onSuccess?.(response, file),
+        onError: (error, file) => callbacksRef.current.onError?.(error, file),
+        onExceed: (files, list) => callbacksRef.current.onExceed?.(files, list),
+        onReject: (files) => callbacksRef.current.onReject?.(files),
+        onQueueChange: (queueItems) => callbacksRef.current.onQueueChange?.(queueItems),
+        onChunkProgress: (chunk, progress, file) => callbacksRef.current.onChunkProgress?.(chunk, progress, file)
+      }
+    })
+  );
+  useEffect(() => {
+    previewUrls.current.sync(fileList);
+  }, [fileList]);
+  useEffect(
+    () => () => {
+      previewUrls.current.dispose();
+      controllerRef.current.dispose();
+    },
+    []
+  );
+  useEffect(() => {
+    if (status === "error") runShakeAnimation(rootRef.current);
+  }, [status, formItemControl?.shakeTrigger]);
+  useImperativeHandle(
+    ref,
+    () => ({
+      focus: () => triggerRef.current?.focus(),
+      submit: () => controllerRef.current.submit(),
+      abort: (uid) => controllerRef.current.abort(uid),
+      retry: (file) => controllerRef.current.retry(file)
+    }),
+    []
+  );
+  const openPicker = useCallback(() => {
+    if (effectiveDisabled) return;
+    inputRef.current?.click();
+  }, [effectiveDisabled]);
+  const handleFileChange = async (event) => {
+    event.stopPropagation();
+    const files = Array.from(event.target.files || []);
+    await controllerRef.current.processFiles(files);
+    event.target.value = "";
+  };
+  const handleRemove = async (file) => {
+    if (effectiveDisabled) return;
+    await controllerRef.current.remove(file);
+  };
+  const handlePreview = (file) => {
+    if (effectiveDisabled) return;
+    if (onPreview) {
+      onPreview(file);
+      return;
+    }
+    const url = previewUrls.current.get(file);
+    if (url) setPreviewSrc(url);
+  };
+  const handleFocusOut = (event) => {
+    onBlur?.(event);
+    const next = event.relatedTarget;
+    if (next && event.currentTarget.contains(next)) return;
+    formItemControl?.onBlur?.();
+  };
+  const triggerAria = {
+    id: triggerId,
+    "aria-invalid": status === "error" ? true : divProps["aria-invalid"],
+    "aria-required": formItemControl?.required || divProps["aria-required"] ? true : void 0,
+    "aria-describedby": describedBy,
+    "aria-labelledby": labelledby,
+    "aria-controls": inputId
+  };
+  const renderTrigger = () => {
+    if (drag) {
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref: triggerRef,
+          className: getDragAreaClasses(isDragging, effectiveDisabled),
+          onClick: openPicker,
+          onKeyDown: (event) => {
+            if (effectiveDisabled) return;
+            if (event.key === "Enter" || event.key === " ") {
+              event.preventDefault();
+              openPicker();
+            }
+          },
+          onDragOver: (event) => {
+            const result = handleUploadDragOver(event, effectiveDisabled);
+            if (!result.handled) return;
+            setIsDragging(result.isDragging);
+          },
+          onDragLeave: (event) => {
+            const result = handleUploadDragLeave(event, effectiveDisabled, event.currentTarget);
+            if (!result.handled) return;
+            setIsDragging(result.isDragging);
+          },
+          onDrop: async (event) => {
+            const result = handleUploadDrop(event, effectiveDisabled);
+            if (!result.handled) return;
+            setIsDragging(false);
+            const read = readUploadDropFiles(event.dataTransfer);
+            if (read.rejectedDirectories.length > 0) {
+              onReject?.(
+                read.rejectedDirectories.map((file) => ({ file, reason: "directory" }))
+              );
+            }
+            await controllerRef.current.processFiles(read.files);
+          },
+          role: "button",
+          tabIndex: effectiveDisabled ? -1 : 0,
+          "aria-disabled": effectiveDisabled,
+          "aria-label": children ? void 0 : labels.dragAreaAriaLabel,
+          ...triggerAria,
+          children: children || /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              Icon,
+              {
+                name: "upload",
+                className: "w-12 h-12 mb-3 text-[var(--tiger-text-muted,#9ca3af)]",
+                "aria-hidden": true
+              }
+            ),
+            /* @__PURE__ */ jsxs("p", { className: "mb-2 text-sm", children: [
+              /* @__PURE__ */ jsx("span", { className: "font-semibold", children: labels.clickToUploadText }),
+              " ",
+              labels.dragAndDropText
+            ] }),
+            accept && /* @__PURE__ */ jsx("p", { className: "text-xs text-[var(--tiger-text-muted,#6b7280)]", children: interpolateUploadLabel(labels.acceptInfoText, { accept }) }),
+            maxSize ? /* @__PURE__ */ jsx("p", { className: "text-xs text-[var(--tiger-text-muted,#6b7280)]", children: interpolateUploadLabel(labels.maxSizeInfoText, {
+              maxSize: formatFileSize(maxSize)
+            }) }) : null
+          ] })
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      Button,
+      {
+        ref: triggerRef,
+        type: "button",
+        variant: "outline",
+        size: "sm",
+        disabled: effectiveDisabled,
+        onClick: openPicker,
+        "aria-label": children ? void 0 : labels.buttonAriaLabel,
+        ...triggerAria,
+        children: children || labels.selectFileText
+      }
+    );
+  };
+  const renderProgress = (file, errorId) => /* @__PURE__ */ jsxs(Fragment, { children: [
+    file.status === "uploading" ? /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: uploadProgressTrackClasses,
+        role: "progressbar",
+        "aria-valuemin": 0,
+        "aria-valuemax": 100,
+        "aria-valuenow": file.progress ?? 0,
+        children: /* @__PURE__ */ jsx("div", { className: uploadProgressValueClasses, style: { width: `${file.progress ?? 0}%` } })
+      }
+    ) : null,
+    file.status === "error" && file.error ? /* @__PURE__ */ jsx("p", { id: errorId, className: "text-xs text-[var(--tiger-error,#dc2626)]", children: file.error }) : null
+  ] });
+  const renderActions = (file, picture) => {
+    const canPreview = Boolean(onPreview) || isImageUploadFile(file) && Boolean(previewUrls.current.get(file));
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      canPreview ? /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: picture ? "text-[var(--tiger-on-primary,#ffffff)] focus:outline-none focus-visible:ring-2 focus-visible:ring-[var(--tiger-focus-ring,var(--tiger-primary,#2563eb))] rounded-sm" : uploadIconActionClasses,
+          disabled: effectiveDisabled,
+          tabIndex: effectiveDisabled ? -1 : 0,
+          onClick: () => handlePreview(file),
+          "aria-label": interpolateUploadLabel(labels.previewFileAriaLabel, {
+            fileName: file.name
+          }),
+          children: /* @__PURE__ */ jsx(Icon, { name: "eye", className: picture ? "w-6 h-6" : "w-5 h-5", "aria-hidden": true })
+        }
+      ) : null,
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: picture ? "text-[var(--tiger-on-primary,#ffffff)] focus:outline-none focus-visible:ring-2 focus-visible:ring-[var(--tiger-focus-ring,var(--tiger-primary,#2563eb))] rounded-sm" : uploadIconActionClasses,
+          disabled: effectiveDisabled,
+          tabIndex: effectiveDisabled ? -1 : 0,
+          onClick: () => handleRemove(file),
+          "aria-label": interpolateUploadLabel(labels.removeFileAriaLabel, { fileName: file.name }),
+          children: /* @__PURE__ */ jsx(
+            Icon,
+            {
+              name: picture ? "trash" : "close",
+              className: picture ? "w-6 h-6" : "w-5 h-5",
+              "aria-hidden": true
+            }
+          )
+        }
+      )
+    ] });
+  };
+  const renderTextItem = (file) => {
+    const errorId = file.status === "error" && file.error ? `${file.uid}-error` : void 0;
+    const thumb = listType === "picture" ? previewUrls.current.get(file) : void 0;
+    return /* @__PURE__ */ jsxs("li", { className: getFileListItemClasses(file.status), "aria-describedby": errorId, children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center flex-1 min-w-0 gap-2", children: [
+        listType === "picture" ? thumb ? /* @__PURE__ */ jsx("img", { src: thumb, alt: "", className: "w-10 h-10 rounded object-cover flex-shrink-0" }) : /* @__PURE__ */ jsx(Icon, { name: "document", className: "w-5 h-5 flex-shrink-0", "aria-hidden": true }) : /* @__PURE__ */ jsx(Icon, { name: "document", className: "w-5 h-5 flex-shrink-0", "aria-hidden": true }),
+        /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
+          /* @__PURE__ */ jsx("p", { className: "text-sm font-medium truncate", children: file.name }),
+          file.size != null ? /* @__PURE__ */ jsx("p", { className: "text-xs text-[var(--tiger-text-muted,#6b7280)]", children: formatFileSize(file.size) }) : null,
+          renderProgress(file, errorId)
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: uploadItemActionsClasses, children: [
+        /* @__PURE__ */ jsx(UploadStatusIcon, { status: file.status, labels, size: "sm" }),
+        renderActions(file, false)
+      ] })
+    ] }, file.uid);
+  };
+  const renderPictureCard = (file) => {
+    const imageUrl = previewUrls.current.get(file);
+    const errorId = file.status === "error" && file.error ? `${file.uid}-error` : void 0;
+    return /* @__PURE__ */ jsxs("div", { className: getPictureCardClasses(file.status), "aria-describedby": errorId, children: [
+      /* @__PURE__ */ jsx("div", { className: uploadPictureImageWrapClasses, children: imageUrl ? /* @__PURE__ */ jsx("img", { src: imageUrl, alt: file.name, className: "w-full h-full object-cover" }) : /* @__PURE__ */ jsx("span", { className: "flex h-full w-full items-center justify-center px-2 text-xs text-center text-[var(--tiger-text-muted,#6b7280)]", children: file.name }) }),
+      /* @__PURE__ */ jsx("div", { className: uploadPictureOverlayClasses, children: renderActions(file, true) }),
+      file.status === "uploading" ? /* @__PURE__ */ jsxs("div", { className: "absolute inset-0 flex flex-col items-center justify-center bg-[var(--tiger-surface,#ffffff)]/80", children: [
+        /* @__PURE__ */ jsx(UploadStatusIcon, { status: "uploading", labels, size: "lg" }),
+        renderProgress(file)
+      ] }) : null,
+      file.status === "error" && file.error ? /* @__PURE__ */ jsx(
+        "p",
+        {
+          id: errorId,
+          className: "absolute bottom-1 inset-x-1 text-[10px] text-[var(--tiger-error,#dc2626)] truncate",
+          children: file.error
+        }
+      ) : null
+    ] }, file.uid);
+  };
+  const renderFileList = () => {
+    if (!showFileList || fileList.length === 0) return null;
+    if (listType === "picture-card") {
+      return /* @__PURE__ */ jsx("div", { className: uploadPictureListClasses, children: fileList.map(renderPictureCard) });
+    }
+    return /* @__PURE__ */ jsx("ul", { className: uploadListClasses, role: "list", "aria-label": labels.uploadedFilesAriaLabel, children: fileList.map(renderTextItem) });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ...divProps,
+      ref: rootRef,
+      className: classNames("tiger-upload", className),
+      style,
+      onBlur: handleFocusOut,
+      children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref: inputRef,
+            id: inputId,
+            type: "file",
+            accept,
+            multiple,
+            disabled: effectiveDisabled,
+            className: uploadFileInputClasses,
+            onChange: handleFileChange,
+            "aria-hidden": "true",
+            tabIndex: -1
+          }
+        ),
+        fieldName ? fileList.map((file) => /* @__PURE__ */ jsx("input", { type: "hidden", name: fieldName, value: file.url ?? file.uid }, file.uid)) : null,
+        renderTrigger(),
+        renderFileList(),
+        previewSrc ? /* @__PURE__ */ jsx(
+          ImagePreview,
+          {
+            images: [previewSrc],
+            open: true,
+            onOpenChange: (open) => !open && setPreviewSrc(null)
+          }
+        ) : null
+      ]
+    }
+  );
+});
+Upload.displayName = "Upload";
+
+export {
+  Upload
+};

package/dist/chunk-RUIFGSVN.mjs

@@ -0,0 +1,141 @@
+// src/components/ConfigProvider.tsx
+import React, { useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import {
+  isLazyTigerLocale,
+  getImmediateTigerLocale,
+  resolveTigerLocale,
+  resolveTigerConfig,
+  createDocumentConfigHandle,
+  devWarn
+} from "@expcat/tigercat-core";
+
+// src/utils/global-locale.ts
+import {
+  createTigerLocaleScope,
+  createGlobalTigerLocaleHandle,
+  getGlobalTigerLocale,
+  resetTigerLocaleScope
+} from "@expcat/tigercat-core";
+
+// src/components/ConfigProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var EMPTY_CONFIG = {};
+var TigerConfigContext = React.createContext(EMPTY_CONFIG);
+var ConfigProvider = ({
+  locale,
+  direction,
+  theme,
+  colorScheme,
+  children
+}) => {
+  const parent = useContext(TigerConfigContext);
+  const isDocumentOwner = parent === EMPTY_CONFIG;
+  const globalLocaleHandleRef = useRef(null);
+  const documentHandleRef = useRef(null);
+  const hydratedDocumentRef = useRef(false);
+  const isLazy = isLazyTigerLocale(locale);
+  const [lazyLocale, setLazyLocale] = useState(void 0);
+  const [localeLoading, setLocaleLoading] = useState(isLazy);
+  const [localeLoadError, setLocaleLoadError] = useState(void 0);
+  const resolvedLocale = isLazy ? lazyLocale : getImmediateTigerLocale(locale);
+  useEffect(() => {
+    if (!isLazyTigerLocale(locale)) {
+      setLazyLocale(getImmediateTigerLocale(locale));
+      setLocaleLoading(false);
+      setLocaleLoadError(void 0);
+      return;
+    }
+    let cancelled = false;
+    setLocaleLoading(true);
+    setLocaleLoadError(void 0);
+    resolveTigerLocale(locale).then(
+      (result) => {
+        if (!cancelled) {
+          setLazyLocale(result);
+          setLocaleLoading(false);
+          setLocaleLoadError(void 0);
+        }
+      },
+      (reason) => {
+        if (!cancelled) {
+          const error = reason instanceof Error ? reason : new Error(String(reason));
+          setLocaleLoading(false);
+          setLocaleLoadError(error);
+          devWarn(
+            "ConfigProvider.localeLoad",
+            "[Tigercat] ConfigProvider failed to load locale; keeping the previous locale."
+          );
+        }
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [locale]);
+  const value = useMemo(
+    () => resolveTigerConfig({
+      locale: resolvedLocale,
+      localeLoading,
+      localeLoadError,
+      direction,
+      theme,
+      colorScheme,
+      parent
+    }),
+    [resolvedLocale, localeLoading, localeLoadError, direction, theme, colorScheme, parent]
+  );
+  if (!globalLocaleHandleRef.current) {
+    globalLocaleHandleRef.current = createGlobalTigerLocaleHandle(value.locale);
+  } else {
+    globalLocaleHandleRef.current.update(value.locale);
+  }
+  useLayoutEffect(() => {
+    return () => {
+      globalLocaleHandleRef.current?.dispose();
+      globalLocaleHandleRef.current = null;
+    };
+  }, []);
+  useLayoutEffect(() => {
+    if (!isDocumentOwner) return;
+    const handle = createDocumentConfigHandle();
+    documentHandleRef.current = handle;
+    return () => {
+      handle.dispose();
+      documentHandleRef.current = null;
+      hydratedDocumentRef.current = false;
+    };
+  }, [isDocumentOwner]);
+  useLayoutEffect(() => {
+    if (!documentHandleRef.current) return;
+    documentHandleRef.current.apply(
+      {
+        theme: value.theme,
+        colorScheme: value.colorScheme,
+        direction: value.direction,
+        lang: value.locale?.locale
+      },
+      { hydrateAuto: !hydratedDocumentRef.current }
+    );
+    hydratedDocumentRef.current = true;
+  }, [value.theme, value.colorScheme, value.direction, value.locale?.locale]);
+  return /* @__PURE__ */ jsx(TigerConfigContext.Provider, { value, children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "contents",
+      "data-tiger-config-root": "",
+      dir: value.direction,
+      lang: value.locale?.locale,
+      children
+    }
+  ) });
+};
+ConfigProvider.displayName = "TigerConfigProvider";
+function useTigerConfig() {
+  return useContext(TigerConfigContext);
+}
+
+export {
+  getGlobalTigerLocale,
+  ConfigProvider,
+  useTigerConfig
+};