@rainbow-oh/yee-c 0.6.4 → 0.8.0

package/dist/esm/Tree/utils/tree-tools.d.ts

@@ -4,6 +4,17 @@ export interface MoveInfo {
     dragKey: string | number;
     dropKey: string | number;
     position: DragPosition;
+    /**
+     * Full key path from root to the dragged node (inclusive).
+     * When provided, enables precise matching even with non-unique keys.
+     * Example: ['root', 'parent', 'child']
+     */
+    dragPath?: Array<string | number>;
+    /**
+     * Full key path from root to the drop target node (inclusive).
+     * When provided, enables precise matching even with non-unique keys.
+     */
+    dropPath?: Array<string | number>;
 }
 /**
  * Reorder the nested dataSource immutably after a drag.
@@ -13,6 +24,10 @@ export interface MoveInfo {
  * nodes are reused by reference (data may carry non-cloneable values like
  * React elements / functions in `icon`).
  *
+ * When `dragPath` / `dropPath` are provided in `info`, matching is done by
+ * walking the exact path (supports non-unique keys). Otherwise falls back to
+ * first-match by key (backward compatible).
+ *
  * Returns a brand-new root array; returns the input unchanged if dragKey is
  * not found or drag and drop resolve to the same location.
  */
@@ -20,20 +35,38 @@ export declare function moveTreeNode<T extends Record<string, unknown>>(tree: T
     key: keyof T;
     children: keyof T;
 }): T[];
-export declare function getChildKeys<T extends Record<string, unknown>>(data: T, fieldNames: {
-    key: keyof T;
-    children: keyof T;
-}): Array<string | number>;
+/**
+ * Flatten tree into a flat array with rich metadata.
+ *
+ * Key design decisions:
+ * - Uses `uid` (built from the key path) as the internal identifier, because
+ *   user-provided `key` values may NOT be globally unique across the tree.
+ * - The returned Map is keyed by `uid` for O(1) lookups.
+ * - `childUids` is collected bottom-up in a single pass (O(n) total) instead
+ *   of per-node recursive enumeration (which was O(n²)).
+ */
 export declare function tree2array<T extends Record<string, unknown>>(tree: T | T[], fieldNames: {
     key: keyof T;
     label: keyof T;
     children: keyof T;
 }): [TreeNode<T>[], Map<string, TreeNode<T>>];
-export declare function containsAll<T>(a: Array<T>, b: Array<T>): boolean;
-export declare function removeContainsAll<T>(a: Array<T>, b: Array<T>): T[];
-export declare function getCheckedKeys({ checked, keys, key, map, }: {
+/**
+ * Check whether array `a` contains every element in `b`.
+ */
+export declare function containsAll<T>(a: Set<T>, b: Array<T>): boolean;
+/**
+ * Remove all elements in `b` from `a`.
+ */
+export declare function removeAll<T>(a: Set<T>, b: Array<T>): Set<T>;
+/**
+ * Compute new checked uids when a node is toggled.
+ * Uses Set-based operations for O(1) membership checks.
+ * Disabled nodes are NOT affected by parent/child propagation — their checked
+ * state remains unchanged unless they are the directly toggled node.
+ */
+export declare function getCheckedKeys({ checked, keys, uid, map, }: {
     checked: boolean;
-    keys: Array<string | number>;
-    key: string | number;
+    keys: Set<string>;
+    uid: string;
     map: Map<string, TreeNode<unknown>>;
-}): (string | number)[];
+}): Set<string>;

package/dist/esm/Tree/utils/tree-tools.js

@@ -19,6 +19,10 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
  * nodes are reused by reference (data may carry non-cloneable values like
  * React elements / functions in `icon`).
  *
+ * When `dragPath` / `dropPath` are provided in `info`, matching is done by
+ * walking the exact path (supports non-unique keys). Otherwise falls back to
+ * first-match by key (backward compatible).
+ *
  * Returns a brand-new root array; returns the input unchanged if dragKey is
  * not found or drag and drop resolve to the same location.
  */
@@ -28,12 +32,28 @@ export function moveTreeNode(tree, info, fieldNames) {
     C = fieldNames.children;
   var dragKey = info.dragKey,
     dropKey = info.dropKey,
-    position = info.position;
+    position = info.position,
+    dragPath = info.dragPath,
+    dropPath = info.dropPath;
   var root = Array.isArray(tree) ? tree : [tree];
 
+  /**
+   * Match a node: when a path is provided, match by comparing node key against
+   * the expected key at the current depth; otherwise match by key equality.
+   */
+  var matchNode = function matchNode(node, targetKey, path, depth) {
+    if (path) {
+      return String(node[K]) === String(path[depth]);
+    }
+    return node[K] === targetKey;
+  };
+  var isTargetDepth = function isTargetDepth(path, depth) {
+    if (!path) return true; // no path constraint, match at any depth
+    return depth === path.length - 1;
+  };
+
   // Phase 1: detach the drag node subtree (immutably).
-  // Returns the rebuilt array (without the drag node) plus the detached node.
-  var detach = function detach(nodes) {
+  var detach = function detach(nodes, depth) {
     var found = null;
     var next = [];
     var _iterator = _createForOfIteratorHelper(nodes),
@@ -41,18 +61,22 @@ export function moveTreeNode(tree, info, fieldNames) {
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var n = _step.value;
-        if (n[K] === dragKey) {
-          found = n; // keep the original subtree reference intact
+        if (!found && matchNode(n, dragKey, dragPath, depth) && isTargetDepth(dragPath, depth)) {
+          found = n;
           continue;
         }
         var kids = n[C];
-        if (Array.isArray(kids)) {
-          var r = detach(kids);
+        if (!found && dragPath && Array.isArray(kids) && !matchNode(n, dragKey, dragPath, depth)) {
+          // A path lets us skip branches that cannot contain the drag node.
+          next.push(n);
+        } else if (!found && Array.isArray(kids)) {
+          // On the drag path (or no path constraint), recurse
+          var r = detach(kids, depth + 1);
           if (r.found) {
             found = r.found;
             next.push(_objectSpread(_objectSpread({}, n), {}, _defineProperty({}, C, r.nodes)));
           } else {
-            next.push(n); // unchanged branch: reuse original ref
+            next.push(n);
           }
         } else {
           next.push(n);
@@ -68,15 +92,13 @@ export function moveTreeNode(tree, info, fieldNames) {
       nodes: next
     };
   };
-  var _detach = detach(root),
+  var _detach = detach(root, 0),
     dragNode = _detach.found,
     withoutDrag = _detach.nodes;
-  if (!dragNode) return root; // dragKey not found: no-op
+  if (!dragNode) return root;
 
-  // Phase 2: insert per position into the tree that no longer contains the drag node.
-  // Note: do NOT short-circuit with an early return once inserted — siblings that
-  // follow the matched subtree must still be copied (by reference) or they'd be lost.
-  var insert = function insert(nodes) {
+  // Phase 2: insert per position.
+  var insert = function insert(nodes, depth) {
     var next = [];
     var inserted = false;
     var _iterator2 = _createForOfIteratorHelper(nodes),
@@ -84,28 +106,31 @@ export function moveTreeNode(tree, info, fieldNames) {
     try {
       for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
         var n = _step2.value;
-        if (!inserted && position === 'inside' && n[K] === dropKey) {
+        var isTarget = !inserted && matchNode(n, dropKey, dropPath, depth) && isTargetDepth(dropPath, depth);
+        if (isTarget && position === 'inside') {
           var oldKids = Array.isArray(n[C]) ? n[C] : [];
           next.push(_objectSpread(_objectSpread({}, n), {}, _defineProperty({}, C, [].concat(_toConsumableArray(oldKids), [dragNode]))));
           inserted = true;
           continue;
         }
-        if (!inserted && position === 'before' && n[K] === dropKey) {
+        if (isTarget && position === 'before') {
           next.push(dragNode, n);
           inserted = true;
           continue;
         }
-        if (!inserted && position === 'after' && n[K] === dropKey) {
+        if (isTarget && position === 'after') {
           next.push(n, dragNode);
           inserted = true;
           continue;
         }
         var kids = n[C];
         if (inserted || !Array.isArray(kids)) {
-          // Already inserted, or a leaf with no subtree to search: keep by ref.
+          next.push(n);
+        } else if (dropPath && !matchNode(n, dropKey, dropPath, depth)) {
+          // Not on the drop path at this level, skip recursion
           next.push(n);
         } else {
-          var r = insert(kids);
+          var r = insert(kids, depth + 1);
           if (r.inserted) {
             next.push(_objectSpread(_objectSpread({}, n), {}, _defineProperty({}, C, r.nodes)));
             inserted = true;
@@ -124,28 +149,22 @@ export function moveTreeNode(tree, info, fieldNames) {
       nodes: next
     };
   };
-  var _insert = insert(withoutDrag),
+  var _insert = insert(withoutDrag, 0),
     inserted = _insert.inserted,
     result = _insert.nodes;
-  // If the drop target wasn't found, nothing should change — return the
-  // original (drag node stays put) rather than silently dropping it.
   return inserted ? result : root;
 }
-export function getChildKeys(data, fieldNames) {
-  var key = fieldNames.key,
-    children = fieldNames.children;
-  var _children = data[children];
-  var keys = [];
-  if (Array.isArray(_children) && _children.length) {
-    _children.forEach(function (node) {
-      keys.push(node[key]);
-      if (Array.isArray(node[children])) {
-        keys.push.apply(keys, _toConsumableArray(getChildKeys(node, fieldNames)));
-      }
-    });
-  }
-  return keys;
-}
+
+/**
+ * Flatten tree into a flat array with rich metadata.
+ *
+ * Key design decisions:
+ * - Uses `uid` (built from the key path) as the internal identifier, because
+ *   user-provided `key` values may NOT be globally unique across the tree.
+ * - The returned Map is keyed by `uid` for O(1) lookups.
+ * - `childUids` is collected bottom-up in a single pass (O(n) total) instead
+ *   of per-node recursive enumeration (which was O(n²)).
+ */
 export function tree2array(tree, fieldNames) {
   if (!tree || Array.isArray(tree) && tree.length === 0) return [[], new Map()];
   var data = Array.isArray(tree) ? tree : [tree];
@@ -154,118 +173,214 @@ export function tree2array(tree, fieldNames) {
   var key = fieldNames.key,
     label = fieldNames.label,
     children = fieldNames.children;
+
+  /**
+   * Walk returns the list of descendant uids so the parent can collect them
+   * without a second traversal.
+   * Pushes nodes in PRE-ORDER (parent before children) so that visibleItems
+   * filtering can work in a single forward pass.
+   */
   function walk(_ref) {
-    var data = _ref.data,
-      pKey = _ref.pKey,
+    var node = _ref.data,
+      pUid = _ref.pUid,
       depth = _ref.depth,
       path = _ref.path,
       isLast = _ref.isLast,
       lines = _ref.lines;
-    var _key = data[key];
-    var _label = data[label];
-    var _children = data[children];
-    var nextPath = [].concat(_toConsumableArray(path), [_key]);
-    var uid = nextPath.join('_');
-    var isParent = !!(Array.isArray(_children) && _children.length);
+    var rawKey = node[key];
+    var _label = node[label];
+    var _children = node[children];
+    var nextPath = [].concat(_toConsumableArray(path), [rawKey]);
+    var uid = pUid ? "".concat(pUid, "\0").concat(String(rawKey)) : String(rawKey);
+    var isParent = Array.isArray(_children) && _children.length > 0;
+
+    // Push parent FIRST (pre-order) so visibleItems can rely on forward scan
     var wrapperData = {
       uid: uid,
-      key: _key,
+      key: rawKey,
       label: _label,
+      title: node.title,
       path: path,
-      pKey: pKey,
+      pUid: pUid,
       depth: depth,
       isLeaf: !isParent,
       isLast: isLast,
       lines: lines,
-      disabled: data.disabled,
-      icon: data.icon,
-      childKeys: getChildKeys(data, fieldNames),
-      original: data
+      disabled: node.disabled,
+      icon: node.icon,
+      childUids: undefined,
+      // will be filled after recursion
+      original: node
     };
     res.push(wrapperData);
-    map.set(_key, wrapperData);
-    var total = Array.isArray(_children) ? _children.length : 0;
-    _children === null || _children === void 0 || _children.forEach(function (node, index) {
-      return walk({
-        data: node,
-        pKey: _key,
-        depth: depth + 1,
-        path: nextPath,
-        isLast: index + 1 === total,
-        lines: isLast ? lines : [].concat(_toConsumableArray(lines), [depth])
+    map.set(uid, wrapperData);
+
+    // Recurse children to collect their uids bottom-up
+    var childTotal = isParent ? _children.length : 0;
+    var allDescendantUids = [];
+    if (isParent) {
+      _children.forEach(function (child, index) {
+        var childIsLast = index + 1 === childTotal;
+        var descendantUids = walk({
+          data: child,
+          pUid: uid,
+          depth: depth + 1,
+          path: nextPath,
+          isLast: childIsLast,
+          lines: isLast ? lines : [].concat(_toConsumableArray(lines), [depth])
+        });
+        allDescendantUids.push.apply(allDescendantUids, _toConsumableArray(descendantUids));
       });
-    });
+    }
+
+    // Now fill in childUids
+    if (allDescendantUids.length > 0) {
+      wrapperData.childUids = allDescendantUids;
+    }
+
+    // Return this uid + all descendant uids to the caller
+    return [uid].concat(allDescendantUids);
   }
-  var total = Array.isArray(data) ? data.length : 0;
+  var rootTotal = data.length;
   data.forEach(function (node, index) {
-    return walk({
+    walk({
       data: node,
-      pKey: null,
+      pUid: null,
       depth: 0,
       path: [],
-      isLast: index + 1 === total,
-      lines: index + 1 === total ? [] : [0]
+      isLast: index + 1 === rootTotal,
+      lines: index + 1 === rootTotal ? [] : [0]
     });
   });
   return [res, map];
 }
+
+/**
+ * Check whether array `a` contains every element in `b`.
+ */
 export function containsAll(a, b) {
-  if (b.length > a.length) {
-    return false;
-  }
+  if (!b || b.length === 0) return true;
   return b.every(function (i) {
-    return a.includes(i);
+    return a.has(i);
   });
 }
-export function removeContainsAll(a, b) {
-  if (!b || b.length === 0) return a;
-  var toRemove = new Set(b);
-  return a.filter(function (i) {
-    return !toRemove.has(i);
+
+/**
+ * Remove all elements in `b` from `a`.
+ */
+export function removeAll(a, b) {
+  var result = new Set();
+  a.forEach(function (item) {
+    return result.add(item);
   });
+  var _iterator3 = _createForOfIteratorHelper(b),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var item = _step3.value;
+      result.delete(item);
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return result;
 }
+
+/**
+ * Compute new checked uids when a node is toggled.
+ * Uses Set-based operations for O(1) membership checks.
+ * Disabled nodes are NOT affected by parent/child propagation — their checked
+ * state remains unchanged unless they are the directly toggled node.
+ */
 export function getCheckedKeys(_ref2) {
   var checked = _ref2.checked,
     keys = _ref2.keys,
-    key = _ref2.key,
+    uid = _ref2.uid,
     map = _ref2.map;
-  var newKeys = _toConsumableArray(keys);
-  var item = map.get(key);
-  var childKeys = (item === null || item === void 0 ? void 0 : item.childKeys) || [];
-  var pKey = item === null || item === void 0 ? void 0 : item.pKey;
+  var item = map.get(uid);
+  if (!item) return keys;
+  var childUids = item.childUids || [];
+  var newKeys = new Set();
+  keys.forEach(function (k) {
+    return newKeys.add(k);
+  });
   if (checked) {
-    newKeys = [].concat(_toConsumableArray(newKeys), _toConsumableArray(childKeys), [key]);
-    while (pKey) {
-      var parent = map.get(pKey);
+    // Add this node + non-disabled descendants
+    newKeys.add(uid);
+    var _iterator4 = _createForOfIteratorHelper(childUids),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var cuid = _step4.value;
+        var child = map.get(cuid);
+        if (child && !child.disabled) {
+          newKeys.add(cuid);
+        }
+      }
+
+      // Walk up: if all non-disabled children of an ancestor are checked, check the ancestor
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    var pUid = item.pUid;
+    while (pUid) {
+      var parent = map.get(pUid);
       if (parent) {
-        if (!newKeys.includes(parent.key) && containsAll(newKeys, parent.childKeys)) {
-          newKeys.push(parent.key);
+        if (parent.disabled) {
+          // Stop propagation at disabled ancestors
+          break;
+        }
+        if (!newKeys.has(parent.uid) && parent.childUids) {
+          // Check if all non-disabled children are checked
+          var allNonDisabledChecked = parent.childUids.every(function (cuid) {
+            var child = map.get(cuid);
+            return child && child.disabled || newKeys.has(cuid);
+          });
+          if (allNonDisabledChecked) {
+            newKeys.add(parent.uid);
+          }
         }
-        pKey = parent.pKey;
+        pUid = parent.pUid;
       } else {
-        pKey = null;
+        pUid = null;
       }
     }
   } else {
-    newKeys = newKeys.filter(function (k) {
-      return k !== key;
-    });
-    newKeys = removeContainsAll(newKeys, childKeys);
-    var _loop = function _loop() {
-      var parent = map.get(pKey);
-      if (parent) {
-        if (newKeys.includes(parent.key)) {
-          newKeys = newKeys.filter(function (k) {
-            return k !== parent.key;
-          });
+    // Remove this node + non-disabled descendants
+    newKeys.delete(uid);
+    var _iterator5 = _createForOfIteratorHelper(childUids),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _cuid = _step5.value;
+        var _child = map.get(_cuid);
+        if (_child && !_child.disabled) {
+          newKeys.delete(_cuid);
         }
-        pKey = parent.pKey;
+      }
+
+      // Walk up: uncheck non-disabled ancestors
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    var _pUid = item.pUid;
+    while (_pUid) {
+      var _parent = map.get(_pUid);
+      if (_parent) {
+        if (_parent.disabled) {
+          break;
+        }
+        newKeys.delete(_parent.uid);
+        _pUid = _parent.pUid;
       } else {
-        pKey = null;
+        _pUid = null;
       }
-    };
-    while (pKey) {
-      _loop();
     }
   }
   return newKeys;

package/dist/esm/locale/context.d.ts

@@ -1,16 +1,17 @@
 import React from 'react';
-import type { Locale, TFunction } from './interface';
+import type { Locale, LocaleConfigInput, TFunction } from './interface';
 interface LocaleContextType {
     locale: Locale;
     lang: string;
-    setLocale: (locale: Locale | string) => void;
+    setLocale: (locale: LocaleConfigInput) => void;
     t: TFunction;
 }
 export declare const LocaleContext: React.Context<LocaleContextType>;
 interface LocaleProviderProps {
     children: React.ReactNode;
-    /** Initial locale pack or language code */
-    defaultLocale?: Locale | string;
+    /** Initial locale: a language code, or a full/partial locale object.
+     *  Partial objects are merged onto the matching built-in pack. */
+    defaultLocale?: LocaleConfigInput;
     /** Async locale loader function */
     loadLocale?: (lang: string) => Promise<Locale>;
     /** Whether to auto-fallback to default for missing fields */

package/dist/esm/locale/context.js

@@ -10,9 +10,9 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 // locale/context.tsx
 import React, { createContext, useCallback, useContext, useEffect, useMemo, useState } from 'react';
-import { DEFAULT_LOCALE, LOCALE_CONFIGS } from "./constants";
+import { DEFAULT_LOCALE, DEFAULT_LOCALE_CONFIG, LOCALE_CONFIGS } from "./constants";
 import defaultLocaleData from "./lang/en_US";
-import { isValidLocale, translate } from "./util";
+import { deepMerge, isValidLocale, translate } from "./util";
 
 // ============ Default value (fallback when no Provider) ============
 
@@ -33,6 +33,25 @@ var createDefaultValue = function createDefaultValue() {
 };
 var defaultValue = createDefaultValue();
 
+// ============ Locale input resolution ============
+
+/**
+ * Resolve a locale input (a language code, or a possibly-partial locale
+ * object) into a full `Locale` pack. Partial objects are deep-merged onto the
+ * built-in pack matching their `locale` field, so only the overridden keys
+ * change and everything else is inherited.
+ */
+function resolveLocaleConfigInput(input) {
+  if (typeof input === 'string') {
+    return LOCALE_CONFIGS[input] || defaultLocaleData;
+  }
+  if (input && typeof input.locale === 'string') {
+    var base = LOCALE_CONFIGS[input.locale] || DEFAULT_LOCALE_CONFIG;
+    return deepMerge(base, input);
+  }
+  return defaultLocaleData;
+}
+
 // ============ Context definition ============
 
 export var LocaleContext = /*#__PURE__*/createContext(defaultValue);
@@ -48,11 +67,7 @@ export function LocaleProvider(_ref) {
     fallbackToDefault = _ref$fallbackToDefaul === void 0 ? true : _ref$fallbackToDefaul;
   // State management
   var _useState = useState(function () {
-      if (typeof initialLocale === 'string') {
-        // Prefer sync lookup from static locale packs
-        return LOCALE_CONFIGS[initialLocale] || defaultLocaleData;
-      }
-      return isValidLocale(initialLocale) ? initialLocale : defaultLocaleData;
+      return resolveLocaleConfigInput(initialLocale);
     }),
     _useState2 = _slicedToArray(_useState, 2),
     locale = _useState2[0],
@@ -152,8 +167,9 @@ export function LocaleProvider(_ref) {
       }
       // Otherwise use async loading
       loadAndSetLocale(target);
-    } else if (isValidLocale(target)) {
-      setLocaleState(target);
+    } else if (target && typeof target.locale === 'string') {
+      // Full or partial object: merge onto the matching built-in pack
+      setLocaleState(resolveLocaleConfigInput(target));
       setLang(target.locale);
     }
   }, [loadAndSetLocale]);

package/dist/esm/locale/interface.d.ts

@@ -126,4 +126,24 @@ type ExtractParams<T extends string> = T extends `${infer Pre}{${infer P}}${infe
 } : Record<string, never>;
 export type LocaleParams<K extends LocaleKey> = ExtractParams<K extends keyof Locale ? Locale[K] : K extends `${infer A}.${infer B}` ? A extends keyof Locale ? B extends keyof Locale[A] ? Locale[A][B] : never : never : never>;
 export type TFunction = <K extends LocaleKey>(key: K, params?: LocaleParams<K>) => string;
+/**
+ * Recursively-optional version of T. Every level is optional; arrays are kept
+ * as-is (replaced wholesale rather than element-merged).
+ *
+ * Used so a locale override only needs to specify the keys it changes:
+ * `{ datepicker: { now: 'Now' } }` is a valid `DeepPartial<Locale>`.
+ */
+export type DeepPartial<T> = T extends (...args: any[]) => any ? T : T extends object ? T extends readonly any[] ? T : {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * Locale input accepted by `LocaleProvider` / `useLocale().setLocale`:
+ * - a language code string (`'zh_CN'`), resolved from the built-in packs, or
+ * - a (possibly partial) locale object. A partial object MUST carry `locale`
+ *   so the provider knows which built-in pack to merge the overrides onto;
+ *   only the keys you specify are overridden, everything else is inherited.
+ */
+export type LocaleConfigInput = string | (DeepPartial<Locale> & {
+    locale: string;
+});
 export {};

package/dist/esm/locale/util.d.ts

@@ -1,4 +1,4 @@
-import type { Locale } from './interface';
+import type { DeepPartial, Locale } from './interface';
 /**
  * Deep get object value
  * get(obj, 'a.b.c') => obj.a.b.c
@@ -16,11 +16,11 @@ export declare function isValidLocale(obj: any): obj is Locale;
  * Deep merge two objects
  * Used to merge custom config with default config
  */
-export declare function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T;
+export declare function deepMerge<T extends Record<string, any>>(target: T, source: DeepPartial<NoInfer<T>>): T;
 /**
  * Ensure locale pack completeness, fill missing fields with default values
  */
-export declare function normalizeLocale(locale: Partial<Locale>): Locale;
+export declare function normalizeLocale(locale: DeepPartial<Locale>): Locale;
 /**
  * Get translation text from locale, supports fallback
  * @param locale Current locale pack