@vef-framework/components 1.0.128 → 1.0.129

package/esm/vef-select/hooks/use-select-instance.js

@@ -1,21 +1,2 @@
 "use strict";
-import { useRef, useImperativeHandle } from 'react';
-
-"use strict";
-function useSelectInstance(ref, dataOptions) {
-  const selectRef = useRef(null);
-  useImperativeHandle(ref, () => ({
-    blur: () => {
-      selectRef.current?.blur();
-    },
-    focus: () => {
-      selectRef.current?.focus({
-        preventScroll: true
-      });
-    },
-    getDataOptions: () => dataOptions
-  }));
-  return selectRef;
-}
-
-export { useSelectInstance };
+import{useRef as u,useImperativeHandle as n}from"react";function c(t,r){const e=u(null);return n(t,()=>({blur:()=>{e.current?.blur()},focus:()=>{e.current?.focus({preventScroll:!0})},getDataOptions:()=>r})),e}export{c as useSelectInstance};

package/esm/vef-select/index.js

@@ -1,101 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { useOptionFilter } from '@vef-framework/hooks';
-import { styles } from '@vef-framework/shared';
-import { Select } from 'antd';
-import { memo, forwardRef } from 'react';
-import '../internal/index.js';
-import VefLoadingPlaceholder from '../vef-loading-placeholder/index.js';
-import { useDataOptions } from './hooks/use-data-options.js';
-import { useFieldNames } from './hooks/use-field-names.js';
-import { useRenderLabel } from './hooks/use-render-label.js';
-import { useRenderOption } from './hooks/use-render-option.js';
-import { useSelectInstance } from './hooks/use-select-instance.js';
-import { convertBasicSizeToUiSize } from '../internal/utils.js';
-
-"use strict";
-const listHeight = 280;
-const loadingPlaceholder = /* @__PURE__ */ jsx("div", { css: { height: listHeight / 2 }, children: /* @__PURE__ */ jsx(VefLoadingPlaceholder, {}) });
-function VefSelectBase({
-  defaultValue,
-  value,
-  size,
-  clearable,
-  disabled,
-  placeholder,
-  variant,
-  onClear,
-  onBlur,
-  onFocus,
-  onChange,
-  onSelect,
-  onDeselect,
-  multiple = false,
-  grouped = false,
-  maxCount,
-  renderOption,
-  filterable = false,
-  filterFromRemote = false,
-  ...restProps
-}, ref) {
-  const {
-    onFilterKeywordChange,
-    normalizedOptions,
-    isLoading,
-    fallbackOptions,
-    isFallbackOptionsLoading
-  } = useDataOptions({
-    value,
-    grouped,
-    multiple,
-    onChange,
-    filterable,
-    filterFromRemote,
-    ...restProps
-  });
-  const renderOptionToUse = useRenderOption(renderOption);
-  const filterOption = useOptionFilter(filterable, filterFromRemote);
-  const fieldNames = useFieldNames(grouped);
-  const renderLabel = useRenderLabel(isFallbackOptionsLoading, fallbackOptions);
-  const selectRef = useSelectInstance(ref, normalizedOptions);
-  return /* @__PURE__ */ jsx(
-    Select,
-    {
-      ref: selectRef,
-      defaultActiveFirstOption: true,
-      allowClear: clearable,
-      css: styles.fullWidth,
-      defaultValue,
-      disabled,
-      fieldNames,
-      filterOption,
-      labelRender: renderLabel,
-      listHeight,
-      loading: isLoading,
-      maxCount: multiple ? maxCount : void 0,
-      maxTagCount: multiple ? "responsive" : void 0,
-      mode: multiple ? "multiple" : void 0,
-      notFoundContent: isLoading ? loadingPlaceholder : void 0,
-      optionRender: renderOptionToUse,
-      options: normalizedOptions,
-      placeholder,
-      showSearch: filterable,
-      size: convertBasicSizeToUiSize(size),
-      value,
-      variant,
-      onBlur,
-      onChange,
-      onClear,
-      onDeselect,
-      onFocus,
-      onSearch: onFilterKeywordChange,
-      onSelect
-    }
-  );
-}
-const VefSelect = memo(
-  forwardRef(VefSelectBase)
-);
-VefSelect.displayName = "VefSelect";
-
-export { VefSelect as default };
+import{jsx as t}from"@emotion/react/jsx-runtime";import{useOptionFilter as k}from"@vef-framework/hooks";import{styles as K}from"@vef-framework/shared";import{Select as T}from"antd";import{memo as A,forwardRef as G}from"react";import"../internal/index.js";import H from"../vef-loading-placeholder/index.js";import{useDataOptions as I}from"./hooks/use-data-options.js";import{useFieldNames as J}from"./hooks/use-field-names.js";import{useRenderLabel as U}from"./hooks/use-render-label.js";import{useRenderOption as W}from"./hooks/use-render-option.js";import{useSelectInstance as q}from"./hooks/use-select-instance.js";import{convertBasicSizeToUiSize as E}from"../internal/utils.js";const m=280,M=t("div",{css:{height:m/2},children:t(H,{})});function P({defaultValue:p,value:i,size:u,clearable:c,disabled:f,placeholder:h,variant:v,onClear:g,onBlur:C,onFocus:F,onChange:r,onSelect:b,onDeselect:O,multiple:e=!1,grouped:l=!1,maxCount:S,renderOption:R,filterable:o=!1,filterFromRemote:n=!1,...x},w){const{onFilterKeywordChange:z,normalizedOptions:a,isLoading:s,fallbackOptions:D,isFallbackOptionsLoading:N}=I({value:i,grouped:l,multiple:e,onChange:r,filterable:o,filterFromRemote:n,...x}),y=W(R),B=k(o,n),L=J(l),V=U(N,D),j=q(w,a);return t(T,{ref:j,defaultActiveFirstOption:!0,allowClear:c,css:K.fullWidth,defaultValue:p,disabled:f,fieldNames:L,filterOption:B,labelRender:V,listHeight:m,loading:s,maxCount:e?S:void 0,maxTagCount:e?"responsive":void 0,mode:e?"multiple":void 0,notFoundContent:s?M:void 0,optionRender:y,options:a,placeholder:h,showSearch:o,size:E(u),value:i,variant:v,onBlur:C,onChange:r,onClear:g,onDeselect:O,onFocus:F,onSearch:z,onSelect:b})}const d=A(G(P));d.displayName="VefSelect";export{d as default};

package/esm/vef-slider/hooks/use-slider-instance.js

@@ -1,14 +1,2 @@
 "use strict";
-import { useRef, useImperativeHandle } from 'react';
-
-"use strict";
-function useSliderInstance(ref) {
-  const sliderRef = useRef(null);
-  useImperativeHandle(ref, () => ({
-    blur: () => sliderRef.current?.blur(),
-    focus: () => sliderRef.current?.focus()
-  }));
-  return sliderRef;
-}
-
-export { useSliderInstance };
+import{useRef as u,useImperativeHandle as t}from"react";function n(r){const e=u(null);return t(r,()=>({blur:()=>e.current?.blur(),focus:()=>e.current?.focus()})),e}export{n as useSliderInstance};

package/esm/vef-slider/index.js

@@ -1,35 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { Slider } from 'antd';
-import { forwardRef, useMemo } from 'react';
-import { useSliderInstance } from './hooks/use-slider-instance.js';
-
-"use strict";
-const VefSlider = forwardRef(({
-  step,
-  tipFormatter,
-  onChange,
-  ...restProps
-}, ref) => {
-  const tooltipProps = useMemo(() => {
-    if (tipFormatter) {
-      return {
-        formatter: (value) => tipFormatter(value)
-      };
-    }
-  }, [tipFormatter]);
-  const sliderRef = useSliderInstance(ref);
-  return /* @__PURE__ */ jsx(
-    Slider,
-    {
-      ref: sliderRef,
-      step: step === "mark" ? null : step,
-      tooltip: tooltipProps,
-      onChange,
-      ...restProps
-    }
-  );
-});
-VefSlider.displayName = "VefSlider";
-
-export { VefSlider as default };
+import{jsx as n}from"@emotion/react/jsx-runtime";import{Slider as p}from"antd";import{forwardRef as l,useMemo as u}from"react";import{useSliderInstance as d}from"./hooks/use-slider-instance.js";const e=l(({step:t,tipFormatter:r,onChange:o,...m},i)=>{const s=u(()=>{if(r)return{formatter:f=>r(f)}},[r]),a=d(i);return n(p,{ref:a,step:t==="mark"?null:t,tooltip:s,onChange:o,...m})});e.displayName="VefSlider";export{e as default};

package/esm/vef-sortable-list/components/overlay-item.js

@@ -1,35 +1,6 @@
 "use strict";
-import { jsx, jsxs, Fragment } from '@emotion/react/jsx-runtime';
-import { HolderOutlined } from '@ant-design/icons';
-import { css } from '@emotion/react';
-
-"use strict";
-const defaultHandleIcon = /* @__PURE__ */ jsx(HolderOutlined, {});
-const handlePresetStyle = css`
+import{jsx as e,jsxs as l,Fragment as a}from"@emotion/react/jsx-runtime";import{HolderOutlined as d}from"@ant-design/icons";import{css as m}from"@emotion/react";const i=e(d,{}),u=m`
   cursor: move;
   user-select: none;
   touch-action: none;
-`;
-function VefOverlayItem({
-  item,
-  renderItem,
-  useHandle,
-  handleClassName,
-  handleStyle,
-  handleIcon
-}) {
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    useHandle && /* @__PURE__ */ jsx(
-      "div",
-      {
-        className: handleClassName,
-        css: handlePresetStyle,
-        style: handleStyle,
-        children: handleIcon ?? defaultHandleIcon
-      }
-    ),
-    renderItem(item, true)
-  ] });
-}
-
-export { VefOverlayItem as default };
+`;function f({item:s,renderItem:n,useHandle:r,handleClassName:t,handleStyle:o,handleIcon:c}){return l(a,{children:[r&&e("div",{className:t,css:u,style:o,children:c??i}),n(s,!0)]})}export{f as default};

package/esm/vef-sortable-list/components/sortable-item.js

@@ -1,79 +1,6 @@
 "use strict";
-import { jsx, jsxs } from '@emotion/react/jsx-runtime';
-import { HolderOutlined } from '@ant-design/icons';
-import { useSortable } from '@dnd-kit/sortable';
-import { CSS } from '@dnd-kit/utilities';
-import { css } from '@emotion/react';
-
-"use strict";
-const defaultHandleIcon = /* @__PURE__ */ jsx(HolderOutlined, {});
-const handlePresetStyle = css`
+import{jsx as s,jsxs as b}from"@emotion/react/jsx-runtime";import{HolderOutlined as g}from"@ant-design/icons";import{useSortable as I}from"@dnd-kit/sortable";import{CSS as C}from"@dnd-kit/utilities";import{css as O}from"@emotion/react";const j=s(g,{}),H=O`
   cursor: move;
   user-select: none;
   touch-action: none;
-`;
-function VefSortableItem({
-  item,
-  itemKey,
-  itemIndex,
-  itemClassName,
-  itemStyle,
-  renderItem,
-  useHandle,
-  useOverlay,
-  handleClassName,
-  handleStyle,
-  handleIcon,
-  disabled
-}) {
-  const {
-    isDragging,
-    attributes,
-    listeners,
-    setNodeRef,
-    setActivatorNodeRef,
-    transition,
-    transform
-  } = useSortable({
-    id: itemKey,
-    disabled,
-    data: {
-      index: itemIndex
-    }
-  });
-  const style = {
-    ...itemStyle,
-    transition,
-    transform: CSS.Transform.toString(transform),
-    ...!useOverlay && isDragging ? {
-      position: "relative",
-      zIndex: 999
-    } : {}
-  };
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      ref: setNodeRef,
-      className: itemClassName,
-      style,
-      ...attributes,
-      ...useHandle ? {} : listeners,
-      children: [
-        useHandle && /* @__PURE__ */ jsx(
-          "div",
-          {
-            ref: setActivatorNodeRef,
-            className: handleClassName,
-            css: handlePresetStyle,
-            style: handleStyle,
-            ...listeners,
-            children: handleIcon ?? defaultHandleIcon
-          }
-        ),
-        renderItem(item, false)
-      ]
-    }
-  );
-}
-
-export { VefSortableItem as default };
+`;function R({item:r,itemKey:i,itemIndex:o,itemClassName:n,itemStyle:a,renderItem:l,useHandle:e,useOverlay:m,handleClassName:d,handleStyle:c,handleIcon:f,disabled:u}){const{isDragging:p,attributes:v,listeners:t,setNodeRef:y,setActivatorNodeRef:S,transition:h,transform:x}=I({id:i,disabled:u,data:{index:o}}),N={...a,transition:h,transform:C.Transform.toString(x),...!m&&p?{position:"relative",zIndex:999}:{}};return b("div",{ref:y,className:n,style:N,...v,...e?{}:t,children:[e&&s("div",{ref:S,className:d,css:H,style:c,...t,children:f??j}),l(r,!1)]})}export{R as default};

package/esm/vef-sortable-list/hooks/use-merged-items.js

@@ -1,22 +1,2 @@
 "use strict";
-import { isNullish } from '@vef-framework/shared';
-import { useState, useCallback } from 'react';
-
-"use strict";
-function useMergedItems(defaultItems, items, onChange) {
-  if (isNullish(defaultItems) && isNullish(items)) {
-    throw new Error("At least one of `defaultItems` and `items` must be provided for VefSortableList component.");
-  }
-  const [internalItems, setInternalItems] = useState(defaultItems ?? []);
-  const mergedItems = items ?? internalItems;
-  const mergedOnChange = useCallback((moveItems) => {
-    if (items) {
-      onChange?.(moveItems(items));
-    } else {
-      setInternalItems(moveItems);
-    }
-  }, [items, onChange]);
-  return [mergedItems, mergedOnChange];
-}
-
-export { useMergedItems };
+import{isNullish as s}from"@vef-framework/shared";import{useState as a,useCallback as f}from"react";function l(e,t,o){if(s(e)&&s(t))throw new Error("At least one of `defaultItems` and `items` must be provided for VefSortableList component.");const[i,m]=a(e??[]),n=t??i,u=f(r=>{t?o?.(r(t)):m(r)},[t,o]);return[n,u]}export{l as useMergedItems};

package/esm/vef-sortable-list/index.js

@@ -1,115 +1,2 @@
 "use strict";
-import { jsx, jsxs } from '@emotion/react/jsx-runtime';
-import { useSensors, useSensor, PointerSensor, DndContext, DragOverlay, closestCenter } from '@dnd-kit/core';
-import { restrictToParentElement, restrictToWindowEdges } from '@dnd-kit/modifiers';
-import { arrayMove, SortableContext, verticalListSortingStrategy, horizontalListSortingStrategy } from '@dnd-kit/sortable';
-import { isFunction } from '@vef-framework/shared';
-import { useMemo, useState, useCallback, memo } from 'react';
-import VefOverlayItem from './components/overlay-item.js';
-import VefSortableItem from './components/sortable-item.js';
-import { useMergedItems } from './hooks/use-merged-items.js';
-
-"use strict";
-const defaultItemKey = "id";
-function VefSortableListBase({
-  defaultItems,
-  items,
-  itemKey = defaultItemKey,
-  className,
-  style,
-  orientation = "vertical",
-  useOverlay = true,
-  restrictStrategy = "parent",
-  onChange,
-  ...restProps
-}) {
-  const [mergedItems, mergedOnChange] = useMergedItems(defaultItems, items, onChange);
-  const sensors = useSensors(useSensor(PointerSensor));
-  const itemKeyFn = useMemo(() => {
-    if (isFunction(itemKey)) {
-      return itemKey;
-    }
-    return (item) => item[itemKey];
-  }, [itemKey]);
-  const [activeItem, setActiveItem] = useState();
-  const handleDragStart = useCallback(({ active }) => {
-    setActiveItem(mergedItems[active.data.current.index]);
-  }, [mergedItems]);
-  const handleDragEnd = useCallback(({ active, over }) => {
-    if (!over) {
-      return;
-    }
-    if (active.id !== over.id) {
-      mergedOnChange(
-        (items2) => arrayMove(
-          items2,
-          active.data.current.index,
-          over.data.current.index
-        )
-      );
-    }
-  }, [mergedOnChange]);
-  const itemKeys = mergedItems.map((item) => itemKeyFn(item));
-  const {
-    itemClassName,
-    itemStyle,
-    disabled,
-    ...overlayItemProps
-  } = restProps;
-  return /* @__PURE__ */ jsx(
-    DndContext,
-    {
-      collisionDetection: closestCenter,
-      sensors,
-      modifiers: [
-        restrictStrategy === "parent" ? restrictToParentElement : restrictToWindowEdges
-      ],
-      onDragEnd: handleDragEnd,
-      onDragStart: handleDragStart,
-      children: /* @__PURE__ */ jsx(
-        SortableContext,
-        {
-          items: itemKeys,
-          strategy: orientation === "vertical" ? verticalListSortingStrategy : horizontalListSortingStrategy,
-          children: /* @__PURE__ */ jsxs("div", { className, style, children: [
-            mergedItems.map((item, index) => {
-              const key = itemKeyFn(item);
-              return /* @__PURE__ */ jsx(
-                VefSortableItem,
-                {
-                  item,
-                  itemIndex: index,
-                  itemKey: key,
-                  ...restProps
-                },
-                key
-              );
-            }),
-            useOverlay && /* @__PURE__ */ jsx(
-              DragOverlay,
-              {
-                className: itemClassName,
-                style: itemStyle,
-                wrapperElement: "div",
-                modifiers: [
-                  restrictStrategy === "parent" ? restrictToParentElement : restrictToWindowEdges
-                ],
-                children: activeItem && /* @__PURE__ */ jsx(
-                  VefOverlayItem,
-                  {
-                    item: activeItem,
-                    ...overlayItemProps
-                  }
-                )
-              }
-            )
-          ] })
-        }
-      )
-    }
-  );
-}
-const VefSortableList = memo(VefSortableListBase);
-VefSortableList.displayName = "VefSortableList";
-
-export { VefSortableList as default };
+import{jsx as r,jsxs as T}from"@emotion/react/jsx-runtime";import{useSensors as V,useSensor as j,PointerSensor as k,DndContext as w,DragOverlay as K,closestCenter as P}from"@dnd-kit/core";import{restrictToParentElement as d,restrictToWindowEdges as p}from"@dnd-kit/modifiers";import{arrayMove as z,SortableContext as F,verticalListSortingStrategy as Q,horizontalListSortingStrategy as R}from"@dnd-kit/sortable";import{isFunction as W}from"@vef-framework/shared";import{useMemo as Y,useState as $,useCallback as u,memo as q}from"react";import A from"./components/overlay-item.js";import B from"./components/sortable-item.js";import{useMergedItems as G}from"./hooks/use-merged-items.js";const H="id";function J({defaultItems:y,items:S,itemKey:i=H,className:g,style:v,orientation:x="vertical",useOverlay:h=!0,restrictStrategy:o="parent",onChange:C,...n}){const[s,m]=G(y,S,C),D=V(j(k)),l=Y(()=>W(i)?i:e=>e[i],[i]),[c,E]=$(),N=u(({active:e})=>{E(s[e.data.current.index])},[s]),b=u(({active:e,over:t})=>{t&&e.id!==t.id&&m(a=>z(a,e.data.current.index,t.data.current.index))},[m]),I=s.map(e=>l(e)),{itemClassName:L,itemStyle:M,disabled:U,...O}=n;return r(w,{collisionDetection:P,sensors:D,modifiers:[o==="parent"?d:p],onDragEnd:b,onDragStart:N,children:r(F,{items:I,strategy:x==="vertical"?Q:R,children:T("div",{className:g,style:v,children:[s.map((e,t)=>{const a=l(e);return r(B,{item:e,itemIndex:t,itemKey:a,...n},a)}),h&&r(K,{className:L,style:M,wrapperElement:"div",modifiers:[o==="parent"?d:p],children:c&&r(A,{item:c,...O})})]})})})}const f=q(J);f.displayName="VefSortableList";export{f as default};

package/esm/vef-space/index.js

@@ -1,26 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { useGapSizeNormalizer } from '@vef-framework/hooks';
-import { isArray } from '@vef-framework/shared';
-import { Space } from 'antd';
-import { useMemo } from 'react';
-
-"use strict";
-function VefSpace({
-  gap,
-  ...restProps
-}) {
-  const normalizeGapSize = useGapSizeNormalizer();
-  const size = useMemo(() => {
-    if (isArray(gap)) {
-      return gap.map((it) => normalizeGapSize(it));
-    }
-    if (gap) {
-      return normalizeGapSize(gap);
-    }
-    return gap;
-  }, [gap, normalizeGapSize]);
-  return /* @__PURE__ */ jsx(Space, { size, ...restProps });
-}
-
-export { VefSpace as default };
+import{jsx as i}from"@emotion/react/jsx-runtime";import{useGapSizeNormalizer as p}from"@vef-framework/hooks";import{isArray as a}from"@vef-framework/shared";import{Space as s}from"antd";import{useMemo as f}from"react";function u({gap:o,...m}){const r=p(),e=f(()=>a(o)?o.map(t=>r(t)):o&&r(o),[o,r]);return i(s,{size:e,...m})}export{u as default};

package/esm/vef-spin/index.js

@@ -1,13 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { Spin } from 'antd';
-
-"use strict";
-function VefSpin({
-  size,
-  ...restProps
-}) {
-  return /* @__PURE__ */ jsx(Spin, { size: size === "medium" ? "default" : size, ...restProps });
-}
-
-export { VefSpin as default };
+import{jsx as i}from"@emotion/react/jsx-runtime";import{Spin as r}from"antd";function f({size:t,...e}){return i(r,{size:t==="medium"?"default":t,...e})}export{f as default};

package/esm/vef-splitter/index.js

@@ -1,21 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { Splitter } from 'antd';
-
-"use strict";
-function VefSplitter({
-  orientation,
-  onResizeBegin,
-  ...rest
-}) {
-  return /* @__PURE__ */ jsx(
-    Splitter,
-    {
-      layout: orientation,
-      onResizeStart: onResizeBegin,
-      ...rest
-    }
-  );
-}
-
-export { VefSplitter as default };
+import{jsx as r}from"@emotion/react/jsx-runtime";import{Splitter as i}from"antd";function n({orientation:t,onResizeBegin:o,...e}){return r(i,{layout:t,onResizeStart:o,...e})}export{n as default};

package/esm/vef-splitter-panel/index.js

@@ -1,13 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { Splitter } from 'antd';
-
-"use strict";
-const { Panel } = Splitter;
-function VefSplitterPanel({
-  ...rest
-}) {
-  return /* @__PURE__ */ jsx(Panel, { ...rest });
-}
-
-export { VefSplitterPanel as default };
+import{jsx as r}from"@emotion/react/jsx-runtime";import{Splitter as o}from"antd";const{Panel:e}=o;function i({...t}){return r(e,{...t})}export{i as default};

package/esm/vef-status/index.js

@@ -1,38 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { useColorTokens } from '@vef-framework/hooks';
-import { Badge } from 'antd';
-import { useMemo } from 'react';
-
-"use strict";
-function VefStatus({
-  processing = false,
-  color = "default",
-  children
-}) {
-  const colorTokens = useColorTokens();
-  const badgeProps = useMemo(() => {
-    if (color === "default") {
-      return {
-        status: "default",
-        text: children
-      };
-    }
-    if (colorTokens.has(color)) {
-      return {
-        status: processing ? "processing" : "default",
-        color: colorTokens.get(color),
-        text: children
-      };
-    }
-    throw new Error(`Invalid color value "${color}" of VefStatus component. Color must be either "default" or a valid color token.`);
-  }, [
-    color,
-    colorTokens,
-    processing,
-    children
-  ]);
-  return /* @__PURE__ */ jsx(Badge, { ...badgeProps });
-}
-
-export { VefStatus as default };
+import{jsx as u}from"@emotion/react/jsx-runtime";import{useColorTokens as a}from"@vef-framework/hooks";import{Badge as l}from"antd";import{useMemo as f}from"react";function n({processing:e=!1,color:o="default",children:r}){const t=a(),s=f(()=>{if(o==="default")return{status:"default",text:r};if(t.has(o))return{status:e?"processing":"default",color:t.get(o),text:r};throw new Error(`Invalid color value "${o}" of VefStatus component. Color must be either "default" or a valid color token.`)},[o,t,e,r]);return u(l,{...s})}export{n as default};

package/esm/vef-table/components/columns/bool.js

@@ -1,92 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-import { css } from '@emotion/react';
-import { VefError, isString, isNullish, isDeepEqual } from '@vef-framework/shared';
-import { useMemo, memo } from 'react';
-import VefText from '../../../vef-text/index.js';
-import { useComputedValues } from '../../hooks/use-computed-values.js';
-
-"use strict";
-function Bool({
-  value,
-  record,
-  rowIndex,
-  columnProps
-}) {
-  if (columnProps.type !== "Boolean") {
-    throw new VefError(-1, "Column type must be Boolean");
-  }
-  const {
-    defaultValue,
-    trueText = "是",
-    falseText = "否",
-    bold,
-    italic,
-    color,
-    width
-  } = columnProps;
-  const [boldToUse, italicToUse, colorOrMapping] = useComputedValues(
-    [
-      {
-        key: "bold",
-        rawValue: bold,
-        defaultValue: false
-      },
-      {
-        key: "italic",
-        rawValue: italic,
-        defaultValue: false
-      },
-      {
-        key: "color",
-        rawValue: color
-      }
-    ],
-    value,
-    record,
-    rowIndex
-  );
-  const colorToUse = useMemo(() => {
-    if (isString(colorOrMapping)) {
-      return colorOrMapping;
-    }
-    if (colorOrMapping) {
-      if (!isNullish(value) && Object.hasOwn(colorOrMapping, value)) {
-        return colorOrMapping[value];
-      } else {
-        return colorOrMapping["*"];
-      }
-    }
-  }, [colorOrMapping, value]);
-  const valueToDisplay = useMemo(() => {
-    if (value) {
-      return value ? trueText : falseText;
-    }
-    return defaultValue;
-  }, [
-    value,
-    trueText,
-    falseText,
-    defaultValue
-  ]);
-  const cssToUse = useMemo(() => {
-    if (width) {
-      return css({
-        maxWidth: `${width}px !important`
-      });
-    }
-  }, [width]);
-  return /* @__PURE__ */ jsx(
-    VefText,
-    {
-      bold: boldToUse,
-      color: colorToUse,
-      css: cssToUse,
-      italic: italicToUse,
-      children: valueToDisplay
-    }
-  );
-}
-const BoolMemo = memo(Bool, isDeepEqual);
-
-export { BoolMemo as default };
+import{jsx as b}from"@emotion/react/jsx-runtime";import{css as h}from"@emotion/react";import{VefError as y,isString as k,isNullish as C,isDeepEqual as T}from"@vef-framework/shared";import{useMemo as e,memo as j}from"react";import B from"../../../vef-text/index.js";import{useComputedValues as E}from"../../hooks/use-computed-values.js";function O({value:o,record:m,rowIndex:s,columnProps:l}){if(l.type!=="Boolean")throw new y(-1,"Column type must be Boolean");const{defaultValue:i,trueText:u="是",falseText:a="否",bold:n,italic:c,color:f,width:t}=l,[p,d,r]=E([{key:"bold",rawValue:n,defaultValue:!1},{key:"italic",rawValue:c,defaultValue:!1},{key:"color",rawValue:f}],o,m,s),w=e(()=>{if(k(r))return r;if(r)return!C(o)&&Object.hasOwn(r,o)?r[o]:r["*"]},[r,o]),V=e(()=>o?o?u:a:i,[o,u,a,i]),x=e(()=>{if(t)return h({maxWidth:`${t}px !important`})},[t]);return b(B,{bold:p,color:w,css:x,italic:d,children:V})}const g=j(O,T);export{g as default};

package/esm/vef-table/components/columns/code.js

@@ -1,11 +1,2 @@
 "use strict";
-import { jsx } from '@emotion/react/jsx-runtime';
-
-"use strict";
-function Code({
-  value
-}) {
-  return /* @__PURE__ */ jsx("span", { children: value });
-}
-
-export { Code as default };
+import{jsx as t}from"@emotion/react/jsx-runtime";function e({value:r}){return t("span",{children:r})}export{e as default};