@rainbow-oh/yee-c 0.4.3 → 0.4.5

package/dist/cjs/Button/button.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
 import type { ButtonProps } from './interface';
 import './style/index.less';
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
 export default Button;

package/dist/cjs/CSV/download.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
 import type { CSVDownloderProps } from './interface';
-declare const Link: React.ForwardRefExoticComponent<CSVDownloderProps & React.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
+declare const Link: React.ForwardRefExoticComponent<CSVDownloderProps & React.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
 export default Link;

package/dist/cjs/Carousel/carousel.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import type { CarouselProps } from './interface';
+import type { CarouselContextProps, CarouselProps } from './interface';
 import './style/index.less';
-export declare const CarouselCtx: React.Context<any>;
+export declare const CarouselCtx: React.Context<CarouselContextProps>;
 declare const Carousel: React.ForwardRefExoticComponent<CarouselProps & React.RefAttributes<HTMLDivElement>>;
 export default Carousel;

package/dist/cjs/Carousel/carousel.js

@@ -71,7 +71,11 @@ var import_mergeContextToProps = __toESM(require("../utils/mergeContextToProps")
 var import_carousel_item = __toESM(require("./carousel-item"));
 var import_style = require("./style/index.less");
 var DEFAULT_ANIMATION_DURATION = 500;
-var CarouselCtx = import_react.default.createContext({});
+var CarouselCtx = import_react.default.createContext({
+  prefixCls: "yee-carousel",
+  effect: "scrollx",
+  current: 1
+});
 var Carousel = import_react.default.forwardRef(
   (baseprops, ref) => {
     const { carousel } = (0, import_react.useContext)(import_Config_Provider.GlobalContext);
@@ -283,7 +287,10 @@ var Carousel = import_react.default.forwardRef(
     };
     const renderFadeChilds = () => {
       return import_react.default.Children.map(children, (child, index) => {
-        return import_react.default.cloneElement(child, { index });
+        return import_react.default.cloneElement(
+          child,
+          { index }
+        );
       });
     };
     const renderWrapedChilds = () => {

package/dist/cjs/Carousel/interface.d.ts

@@ -1,5 +1,10 @@
 /// <reference types="react" />
 export type SemanticDOM = 'dot' | 'prev' | 'next';
+export interface CarouselContextProps {
+    prefixCls: string;
+    effect: 'fade' | 'scrollx';
+    current: number;
+}
 export interface CarouselItemProps {
     index: number;
     style?: React.CSSProperties;

package/dist/cjs/Cascader/cascader.js

@@ -88,7 +88,7 @@ var Cascader = (baseprops) => {
     options,
     placement = "bottomLeft",
     popupClassName,
-    searchable,
+    searchable = true,
     fieldNames = {
       label: "label",
       value: "value",
@@ -149,8 +149,6 @@ var Cascader = (baseprops) => {
         currentValue || [],
         flatOptions,
         {
-          needNext: true,
-          // Set to true to expand to full path
           multiple
         }
       );
@@ -170,9 +168,9 @@ var Cascader = (baseprops) => {
     setSearchValue(value2);
   };
   const onNodeMouseEnter = (item, level) => {
-    if (expandTrigger === "hover" && (0, import_utils.hasChild)(item)) {
+    if (expandTrigger === "hover" && !item.isLeaf) {
       const queue = columns.slice(0, level + 1);
-      queue.push(item.children);
+      queue.push((0, import_utils.getChildren)(flatOptions, item.uid));
       setColumns(queue);
       setExpandedPath((prev) => [
         ...prev.slice(0, level),
@@ -186,17 +184,17 @@ var Cascader = (baseprops) => {
       const traverse = (currentNode, depth) => {
         if (depth > maxDepth)
           return;
-        if (!(0, import_utils.hasChild)(currentNode)) {
+        if (currentNode.isLeaf) {
           paths.push(currentNode.path);
           return;
         }
-        const children2 = currentNode.children;
+        const children2 = (0, import_utils.getChildren)(flatOptions, currentNode.uid);
         children2.forEach((child) => traverse(child, depth + 1));
       };
       traverse(node, 0);
       return paths;
     },
-    []
+    [flatOptions]
   );
   const onItemClick = (0, import_react.useCallback)(
     (item, checkable = false) => {
@@ -208,58 +206,48 @@ var Cascader = (baseprops) => {
       if (multiple && checkable) {
         const currentValue = mergedValue;
         const isSelected = currentValue.some((v) => (0, import_isEqual.default)(v, item.path));
-        if ((0, import_utils.hasChild)(item)) {
+        if (!item.isLeaf) {
           const descendantPaths = getAllDescendantPaths(item, 50);
-          const descendantPathStrs = descendantPaths.map((p) => p.join("-"));
-          let filteredValue = currentValue.filter((v) => {
-            const pathStr = v.join("-");
-            return !descendantPathStrs.some(
-              (descPathStr) => pathStr.startsWith(descPathStr)
-            );
-          });
+          let filteredValue = currentValue.filter(
+            (v) => !descendantPaths.some(
+              (descPath) => (0, import_utils.isSamePrefixPath)(descPath, v)
+            )
+          );
           if (!isSelected) {
             filteredValue = [...filteredValue, ...descendantPaths];
           }
           newValue = filteredValue;
-          newOpts = filteredValue.map((path) => {
-            return path.map((_, i) => {
-              const uid = path.slice(0, i + 1).join("-");
-              return nodeMap.get(uid);
-            });
-          });
+          newOpts = filteredValue.map(
+            (path) => path.map((_, i) => nodeMap.get((0, import_utils.pathToUid)(path.slice(0, i + 1))))
+          );
         } else {
           if (isSelected) {
             newValue = currentValue.filter((v) => !(0, import_isEqual.default)(v, item.path));
           } else {
             newValue = [...currentValue, item.path];
           }
-          newOpts = newValue.map((path) => {
-            return path.map((_, i) => {
-              const uid = path.slice(0, i + 1).join("-");
-              return nodeMap.get(uid);
-            });
-          });
+          newOpts = newValue.map(
+            (path) => path.map((_, i) => nodeMap.get((0, import_utils.pathToUid)(path.slice(0, i + 1))))
+          );
         }
         changed = true;
       } else if (shouldSelect) {
         newValue = multiple ? [...mergedValue, item.path] : item.path;
         newOpts = multiple ? [
-          ...mergedValue.map((item2) => {
-            const vs = item2;
-            const arr = vs.map((_, i) => vs.slice(0, i + 1).join("-"));
-            return arr.map((uid) => nodeMap.get(uid));
+          ...mergedValue.map((path) => {
+            const vs = path;
+            return vs.map(
+              (_, i) => nodeMap.get((0, import_utils.pathToUid)(vs.slice(0, i + 1)))
+            );
           }),
-          [
-            item.path.map((_, i) => {
-              const uid = item.path.slice(0, i + 1).join("-");
-              return nodeMap.get(uid);
-            })
-          ]
+          item.path.map(
+            (_, i) => nodeMap.get((0, import_utils.pathToUid)(item.path.slice(0, i + 1)))
+          )
         ] : flatOptions.filter((opt) => {
-          const arr = item.path.map(
-            (_, i) => item.path.slice(0, i + 1).join("-")
+          const ancestors = item.path.map(
+            (_, i) => (0, import_utils.pathToUid)(item.path.slice(0, i + 1))
           );
-          return arr.includes(opt.uid);
+          return ancestors.includes(opt.uid);
         });
         changed = true;
       } else {
@@ -304,7 +292,7 @@ var Cascader = (baseprops) => {
     if (!mergedValue || mergedValue.length === 0)
       return { options: [], selectedKeys: [] };
     const { fullNode = false, onlyParentNode = false } = props;
-    const formatKey = (val) => val.join("-");
+    const formatKey = (val) => (0, import_utils.pathToUid)(val);
     let rawValues = [];
     if (multiple) {
       rawValues = mergedValue;
@@ -314,28 +302,24 @@ var Cascader = (baseprops) => {
     const selectedKeys = multiple ? rawValues.map(formatKey) : rawValues[0] ? [formatKey(rawValues[0])] : [];
     let displayValues = rawValues;
     if (multiple && onlyParentNode) {
-      const parentIds = [];
-      const childPathStrs = new Set(rawValues.map((v) => v.join("-")));
-      nodeMap.forEach((node, uid) => {
-        var _a2;
-        if ((0, import_utils.hasChild)(node)) {
-          const allChildrenSelected = (_a2 = node.children) == null ? void 0 : _a2.every(
-            (child) => childPathStrs.has(child.path.join("-"))
+      const selectedPathKeys = new Set(rawValues.map(import_utils.pathToUid));
+      const parentPaths = [];
+      nodeMap.forEach((node) => {
+        if (!node.isLeaf) {
+          const allChildrenSelected = (0, import_utils.getChildren)(flatOptions, node.uid).every(
+            (child) => selectedPathKeys.has((0, import_utils.pathToUid)(child.path))
           );
           if (allChildrenSelected) {
-            parentIds.push(uid);
+            parentPaths.push(node.path);
           }
         }
       });
-      displayValues = rawValues.filter((path) => {
-        const pathStr = path.join("-");
-        return !parentIds.some(
-          (parentId) => pathStr.startsWith(parentId + "-")
-        );
-      });
+      displayValues = rawValues.filter(
+        (path) => !parentPaths.some((parentPath) => (0, import_utils.isSamePrefixPath)(parentPath, path))
+      );
     }
     const displayOptions = displayValues.map((valPath) => {
-      var _a2, _b, _c, _d, _e;
+      var _a2, _b, _c, _d;
       const opts = valPath.map((_, i) => {
         const uid = formatKey(valPath.slice(0, i + 1));
         return nodeMap.get(uid);
@@ -348,13 +332,13 @@ var Cascader = (baseprops) => {
             options: opts
           });
         } else {
-          const source = (_b = (_a2 = opts[opts.length - 1]) == null ? void 0 : _a2.$source) != null ? _b : opts[opts.length - 1];
-          label = (_c = source == null ? void 0 : source[optionLabelProp]) != null ? _c : "";
+          const source = (_a2 = opts[opts.length - 1]) == null ? void 0 : _a2.$source;
+          label = (_b = source == null ? void 0 : source[optionLabelProp]) != null ? _b : "";
         }
       } else if (fullNode) {
         label = opts.map((opt) => (opt == null ? void 0 : opt.label) || "").join("/");
       } else {
-        label = (_e = (_d = opts[opts.length - 1]) == null ? void 0 : _d.label) != null ? _e : "";
+        label = (_d = (_c = opts[opts.length - 1]) == null ? void 0 : _c.label) != null ? _d : "";
       }
       return { value: formatKey(valPath), label };
     });
@@ -363,6 +347,7 @@ var Cascader = (baseprops) => {
     multiple,
     mergedValue,
     nodeMap,
+    flatOptions,
     optionLabelProp,
     props.fullNode,
     props.onlyParentNode
@@ -370,13 +355,18 @@ var Cascader = (baseprops) => {
   const onVisibleChange = (newVisible) => {
     popupVisible.current = newVisible;
   };
+  const handleClear = () => {
+    setSearchValue("");
+    setMergedValue([]);
+    onChange == null ? void 0 : onChange([], []);
+  };
   const filteredList = (0, import_react.useMemo)(() => {
     if (!searchValue)
       return [];
     const lowStr = searchValue.toLowerCase();
     const result = [];
     for (const item of flatOptions) {
-      const text = String(item.label);
+      const text = item.labelPath.join(" / ");
       const textLower = text.toLowerCase();
       if (textLower.includes(lowStr)) {
         const matches = [];
@@ -413,7 +403,8 @@ var Cascader = (baseprops) => {
         searchable,
         mode: multiple ? "multiple" : void 0,
         value: searchValue,
-        onSearch: handleSearch
+        onSearch: handleSearch,
+        onClear: handleClear
       })
     );
   };

package/dist/cjs/Cascader/interface.d.ts

@@ -15,11 +15,27 @@ export type FieldNames = {
     value: string;
     children: string;
 };
-export type FlattenOption = Option & {
+/**
+ * Flattened representation of a tree node.
+ *
+ * Deliberately a concrete type (not `Option & ...`) so that:
+ *  - `.label` / `.value` / `.isLeaf` resolve to their precise types (an index
+ *    signature on `Option` would otherwise widen them to `unknown`),
+ *  - `.children` is a compile error — flattened nodes intentionally do not
+ *    carry children; use `getChildren(data, uid)` instead.
+ * Dynamic/extra-field access should go through `$source` (the raw node).
+ */
+export type FlattenOption = {
+    $source: Option;
+    label: string;
+    value: string | number;
     pid: string;
     uid: string;
     path: Array<string | number>;
-    $source: Option;
+    labelPath: string[];
+    level: number;
+    isLeaf: boolean;
+    disabled?: boolean;
 };
 export type NodeProps = FlattenOption & {
     level: number;
@@ -87,6 +103,7 @@ export interface CascaderProps extends Omit<SelectorProps, 'options' | 'value' |
     multiple?: boolean;
     /**
      * Is it searchable
+     * @default true
      */
     searchable?: boolean;
     /**

package/dist/cjs/Cascader/node.js

@@ -42,7 +42,7 @@ var import_cascader = require("./cascader");
 var import_utils = require("./utils");
 var Node = (props) => {
   var _a;
-  const { uid, value, disabled, label, children, isLeaf, path, level } = props;
+  const { uid, value, disabled, label, $source, isLeaf, path, level } = props;
   const {
     prefixCls,
     expandedPath,
@@ -50,10 +50,11 @@ var Node = (props) => {
     mergedValue,
     loadData,
     nodeMap,
+    flatOptions,
     onNodeMouseEnter,
     onItemClick
   } = (0, import_react.useContext)(import_cascader.CascaderCtx);
-  const isParent = (0, import_utils.hasChild)(props);
+  const isParent = !isLeaf;
   const [load, setLoad] = (0, import_react.useState)(0);
   const checked = (0, import_react.useMemo)(() => {
     return mergedValue ? multiple ? mergedValue.some(
@@ -70,7 +71,7 @@ var Node = (props) => {
     var _a2;
     if (loadData && isLeaf === false) {
       setLoad(1);
-      (_a2 = loadData({ label, value, children })) == null ? void 0 : _a2.then(() => {
+      (_a2 = loadData($source)) == null ? void 0 : _a2.then(() => {
         setLoad(2);
       }).catch(() => {
         setLoad(0);
@@ -94,12 +95,16 @@ var Node = (props) => {
     const currentNode = nodeMap.get(uid);
     if (!multiple || !currentNode || !isParent)
       return [false, false];
-    return (0, import_utils.isHalfChecked)(mergedValue, currentNode);
-  }, [nodeMap, uid, mergedValue, isParent, multiple]);
+    return (0, import_utils.isHalfChecked)(
+      mergedValue,
+      currentNode,
+      (0, import_utils.getChildren)(flatOptions, uid)
+    );
+  }, [nodeMap, uid, mergedValue, flatOptions, isParent, multiple]);
   const clsName = (0, import_clsx.default)(
     `${prefixCls}-menu-item`,
     {
-      [`${prefixCls}-menu-item-expand`]: (0, import_utils.hasChild)(props),
+      [`${prefixCls}-menu-item-expand`]: !isLeaf,
       [`${prefixCls}-menu-item-disabled`]: disabled,
       active: ((_a = expandedPath[level]) == null ? void 0 : _a.key) === uid
     },

package/dist/cjs/Cascader/search-list.js

@@ -46,7 +46,8 @@ var renderHighlightText = (matches) => {
 var SearchList = (props) => {
   const { prefixCls, items, onClick } = props;
   return /* @__PURE__ */ import_react.default.createElement("ul", { className: `${prefixCls}-filter-menu` }, items.length ? items.map((item) => {
-    const title = item.data.title || item.data.label;
+    var _a;
+    const title = ((_a = item.data.$source) == null ? void 0 : _a.title) || item.data.labelPath.join(" / ");
     return /* @__PURE__ */ import_react.default.createElement(
       "li",
       {

package/dist/cjs/Cascader/utils/index.d.ts

@@ -7,23 +7,58 @@ import { FieldNames, FlattenOption } from '../interface';
  */
 export declare function hasChild(data: Record<string, any>, childrenField?: string): any;
 /**
- * Populate data into input fields and dropdown lists from a value array
- * @param arr - The value array representing the selected path
+ * Separator used to build a node's `uid` from its value path. A control
+ * character is used on purpose so it can never appear inside a user value —
+ * this prevents collisions like value `"a-1"` vs path `["a", "1"]` that a plain
+ * `'-'` separator would produce.
+ */
+export declare const UID_SEP = "\u0001";
+/**
+ * Build the canonical uid for a value path. Use this everywhere a path needs
+ * to be turned into a key (nodeMap lookups, selected keys, comparisons) so the
+ * format stays consistent with the `uid`/`pid` produced by `flattenOptions`.
+ * @param path - The value path
+ */
+export declare const pathToUid: (path: Array<string | number>) => string;
+/**
+ * Get the direct flattened children of the node identified by `uid`.
+ *
+ * Flattened nodes intentionally do not carry a `children` reference (it used to
+ * point at the raw, un-flattened subtree and caused type lies). Derive children
+ * from the flat list via `pid` instead — single source of truth.
+ * @param data - The flattened options data
+ * @param uid - The parent node's uid
+ */
+export declare const getChildren: (data: Array<FlattenOption>, uid: string) => FlattenOption[];
+/**
+ * Reconstruct cascade columns and the highlight path from a value path.
+ *
+ * Walks the flattened options level by level, matching each value segment
+ * against the correct parent column via `pid` + `value`. Returns:
+ *  - `queue`: the columns to render (column 0 = root, then each matched
+ *    node's children column).
+ *  - `path`: the highlight breadcrumb shaped as `{ key: uid, label }`, so it
+ *    aligns with `expandedPath[level].key === uid` in the node view.
+ *
+ * Stops safely at the last valid segment if the value path does not exist in
+ * the data source.
+ *
+ * @param arr - The selected path. In `multiple` mode the value is an array of
+ *   paths; the first path is used to drive which columns get expanded.
  * @param data - The flattened options data
  * @param options - Optional configuration
- * @returns A tuple of [queue, path] where queue is the column data and path is the selected path info
+ * @returns A tuple of `[queue, path]`
  */
-export declare const changeToView: (arr: Array<string | number>, data: Array<FlattenOption>, options?: {
-    needNext?: boolean | undefined;
+export declare const changeToView: (arr: Array<string | number> | Array<Array<string | number>>, data: Array<FlattenOption>, options?: {
     multiple?: boolean | undefined;
-} | undefined) => (FlattenOption[][] | {
-    id: string | number;
-    text: string;
-}[])[];
+} | undefined) => [FlattenOption[][], Array<{
+    key: string;
+    label: string;
+}>];
 /**
- * Format a path array into a key string
+ * Format a value path into a key string. Alias of `pathToUid` so all path→key
+ * conversions share one collision-safe format.
  * @param val - The path array
- * @returns A string key joined by '-'
  */
 export declare const formatKey: (val: Array<string | number>) => string;
 /**
@@ -37,13 +72,22 @@ export declare const isSamePrefixPath: (prefix: Array<unknown>, target: Array<un
  * Determine if a node is fully selected or half selected (indeterminate)
  * @param value - The selected value paths
  * @param item - The flatten option node to check
+ * @param children - The node's direct flattened children (derive via `getChildren`)
  * @returns A tuple [checkedAll, indeterminate]
  */
-export declare function isHalfChecked(value: Array<Array<string | number>>, item: FlattenOption): boolean[];
+export declare function isHalfChecked(value: Array<Array<string | number>>, item: FlattenOption, children: FlattenOption[]): boolean[];
 /**
- * Flatten a tree structure into an array for easier searching and traversal
+ * Flatten a tree structure into an array for easier searching and traversal.
+ *
+ * The flattened nodes intentionally do NOT carry a `children` field — use
+ * `getChildren(data, uid)` to read a node's children. `uid`/`pid` are built
+ * via `pathToUid` (collision-safe). Includes a depth cap and a cycle guard so
+ * malformed input (very deep or self-referencing trees) cannot overflow the
+ * stack.
+ *
  * @param tree - The tree data to flatten
  * @param fieldNames - Custom field names for label, value, and children
+ * @param maxDepth - Maximum nesting depth (default 100)
  * @returns An array of flattened options with additional metadata
  */
-export declare const flattenOptions: (tree: Array<Record<string, unknown>>, fieldNames: FieldNames) => FlattenOption[];
+export declare const flattenOptions: (tree: Array<Record<string, unknown>>, fieldNames?: FieldNames, maxDepth?: number) => FlattenOption[];