v-dict 1.2.10 → 2.0.0

package/dist/chunk-SXX4ZFIR.js

@@ -0,0 +1,128 @@
+// src/util.ts
+var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+function clearObj(obj) {
+  for (const key of Object.keys(obj)) {
+    delete obj[key];
+  }
+}
+function mapToObj(map, {
+  obj = {},
+  itemTransformer
+} = {}) {
+  var _a;
+  clearObj(obj);
+  for (const [key, value] of map) {
+    obj[key] = (_a = itemTransformer == null ? void 0 : itemTransformer(value)) != null ? _a : value;
+  }
+  return obj;
+}
+function checkObjItem(item, key, transformer) {
+  if (item.value === void 0) {
+    item.value = key;
+  }
+  if (isFunction(transformer)) {
+    item.value = transformer(item.value);
+  }
+}
+function mapToList(map, {
+  list = [],
+  itemTransformer
+} = {}) {
+  const values = isFunction(itemTransformer) ? map.values().map(itemTransformer) : map.values();
+  list.splice(0, list.length, ...values);
+  return list;
+}
+function toMap(data, { map = /* @__PURE__ */ new Map(), pickValues = [], omitValues = [], transformer } = {}) {
+  const filterFn = (value) => (pickValues.length === 0 || pickValues.includes(value)) && !omitValues.includes(value);
+  map.clear();
+  Object.entries(data).filter(([key, item]) => {
+    checkObjItem(item, key, transformer);
+    return filterFn(item.value);
+  }).forEach(([, item]) => map.set(item.value, item));
+  return map;
+}
+var defineDictData = (data) => data;
+var { toString } = Object.prototype;
+function isPlainObject(obj) {
+  return toString.call(obj) === "[object Object]";
+}
+function merge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source && isPlainObject(source)) {
+    for (const key of Reflect.ownKeys(source)) {
+      const value = source[key];
+      if (isPlainObject(value)) {
+        if (!isPlainObject(target[key])) {
+          target[key] = {};
+        }
+        merge(target[key], value);
+      } else {
+        target[key] = value;
+      }
+    }
+  }
+  return merge(target, ...sources);
+}
+function cloneDeep(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(cloneDeep);
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (value instanceof Map) {
+    const copy = /* @__PURE__ */ new Map();
+    value.forEach((val, key) => {
+      copy.set(cloneDeep(key), cloneDeep(val));
+    });
+    return copy;
+  }
+  if (value instanceof Set) {
+    const copy = /* @__PURE__ */ new Set();
+    value.forEach((val) => {
+      copy.add(cloneDeep(val));
+    });
+    return copy;
+  }
+  if (isPlainObject(value)) {
+    const copy = {};
+    for (const key of Reflect.ownKeys(value)) {
+      copy[key] = cloneDeep(value[key]);
+    }
+    return copy;
+  }
+  return value;
+}
+
+// src/create-promise.ts
+var noop = () => {
+};
+function createPromise(executor) {
+  let resolve = noop;
+  let reject = noop;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+    executor == null ? void 0 : executor(_resolve, _reject);
+  });
+  promise.resolve = resolve;
+  promise.reject = reject;
+  promise.isPending = true;
+  promise.finally(() => {
+    promise.isPending = false;
+  });
+  return promise;
+}
+
+export { cloneDeep, createPromise, defineDictData, isFunction, mapToList, mapToObj, merge, toMap, warn };

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 var vue = require('vue');
 
-// src/dict-manager.ts
+// src/vue/vue-dict-manager.ts
 
 // src/create-promise.ts
 var noop = () => {
@@ -25,6 +25,7 @@ function createPromise(executor) {
 }
 
 // src/util.ts
+var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
 function isFunction(fn) {
   return typeof fn === "function";
 }
@@ -33,10 +34,14 @@ function clearObj(obj) {
     delete obj[key];
   }
 }
-function mapToObj(map, obj = {}) {
+function mapToObj(map, {
+  obj = {},
+  itemTransformer
+} = {}) {
+  var _a;
   clearObj(obj);
   for (const [key, value] of map) {
-    obj[key] = value;
+    obj[key] = (_a = itemTransformer == null ? void 0 : itemTransformer(value)) != null ? _a : value;
   }
   return obj;
 }
@@ -48,20 +53,17 @@ function checkObjItem(item, key, transformer) {
     item.value = transformer(item.value);
   }
 }
-function mapToList(map, list = []) {
-  list.splice(0, list.length, ...map.values());
+function mapToList(map, {
+  list = [],
+  itemTransformer
+} = {}) {
+  const values = isFunction(itemTransformer) ? map.values().map(itemTransformer) : map.values();
+  list.splice(0, list.length, ...values);
   return list;
 }
-function listToMap(list) {
-  return new Map(list.map((item) => [item.value, item]));
-}
-function toMap(data, options = {}) {
-  const { pickValues = [], omitValues = [], transformer } = options;
+function toMap(data, { map = /* @__PURE__ */ new Map(), pickValues = [], omitValues = [], transformer } = {}) {
   const filterFn = (value) => (pickValues.length === 0 || pickValues.includes(value)) && !omitValues.includes(value);
-  if (Array.isArray(data)) {
-    return listToMap(data.filter((item) => filterFn(item.value)));
-  }
-  const map = /* @__PURE__ */ new Map();
+  map.clear();
   Object.entries(data).filter(([key, item]) => {
     checkObjItem(item, key, transformer);
     return filterFn(item.value);
@@ -129,13 +131,13 @@ function cloneDeep(value) {
   return value;
 }
 
-// src/dict-manager.ts
-var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
+// src/vue/vue-dict-manager.ts
 function createDictManager(createDictManagerOptions = {}) {
   const {
     fetch: managerFetch,
     extra: managerExtra,
-    transformer: managerTransformer
+    transformer: managerTransformer,
+    itemTransformer: managerItemTransformer
   } = createDictManagerOptions;
   const maps = vue.reactive(/* @__PURE__ */ Object.create(null));
   const defineDictOptionsMap = /* @__PURE__ */ new Map();
@@ -145,22 +147,29 @@ function createDictManager(createDictManagerOptions = {}) {
       (_a = maps[code]) == null ? void 0 : _a.clear();
       return;
     }
-    clearObj(maps);
+    Object.values(maps).forEach((map) => map.clear());
   }
   function _defineDict(defineDictInternalOptions, code, defineDictOptions) {
     const { pickValues, omitValues, extendCode } = defineDictInternalOptions;
     if (maps[code]) {
       warn(`code "${code}" already exists`);
+    } else {
+      maps[code] = /* @__PURE__ */ new Map();
     }
     const _defineDictOptions = Object.assign(
-      { data: {}, remote: false, fetch: managerFetch, transformer: managerTransformer },
+      {
+        data: {},
+        remote: false,
+        fetch: managerFetch,
+        transformer: managerTransformer,
+        itemTransformer: managerItemTransformer
+      },
       isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions
     );
     defineDictOptionsMap.set(code, cloneDeep(_defineDictOptions));
-    const { data, remote, fetch, extra, transformer } = _defineDictOptions;
-    const globalLoadPromise = vue.shallowRef(null);
-    let loaded = false;
-    maps[code] = /* @__PURE__ */ new Map();
+    const { data, remote, fetch, extra, transformer, itemTransformer } = _defineDictOptions;
+    let globalLoadPromise = null;
+    let init = false;
     async function loadDict(options, mapRef) {
       var _a;
       const dataMap = toMap(cloneDeep(data), { pickValues, omitValues, transformer });
@@ -182,21 +191,23 @@ function createDictManager(createDictManagerOptions = {}) {
         useDictOptions
       );
       const { clone, immediate, refresh } = useDictOptions;
-      const loadPromise = !clone ? globalLoadPromise : vue.shallowRef(createPromise());
-      const mapRef = !clone ? vue.toRef(maps, code) : vue.ref();
+      const loadPromise = vue.shallowRef(
+        !clone ? globalLoadPromise : createPromise()
+      );
+      const mapRef = !clone ? vue.toRef(maps, code) : vue.ref(/* @__PURE__ */ new Map());
       const objRef = vue.ref(/* @__PURE__ */ Object.create(null));
       const listRef = vue.ref([]);
       if (!remote || immediate) {
         if (clone) {
           load();
         } else {
-          if (!globalLoadPromise.value) {
-            globalLoadPromise.value = createPromise();
+          if (!globalLoadPromise) {
+            globalLoadPromise = createPromise();
             load();
           } else {
-            globalLoadPromise.value.then(() => {
-              if (!loaded) {
-                loaded = true;
+            globalLoadPromise.then(() => {
+              if (!init) {
+                init = true;
                 load();
               } else if (refresh) {
                 load();
@@ -205,9 +216,9 @@ function createDictManager(createDictManagerOptions = {}) {
           }
         }
       } else {
-        if (!globalLoadPromise.value) {
-          globalLoadPromise.value = createPromise();
-          globalLoadPromise.value.resolve();
+        if (!globalLoadPromise) {
+          globalLoadPromise = createPromise();
+          globalLoadPromise.resolve();
         }
       }
       function load(options) {
@@ -220,24 +231,30 @@ function createDictManager(createDictManagerOptions = {}) {
         return loadPromise.value;
       }
       function _clear() {
-        var _a;
-        (_a = mapRef.value) == null ? void 0 : _a.clear();
+        mapRef.value.clear();
       }
       vue.watch(
         mapRef,
         (newValue) => {
           newValue != null ? newValue : newValue = /* @__PURE__ */ new Map();
-          mapToObj(newValue, objRef.value);
-          mapToList(newValue, listRef.value);
+          mapToObj(newValue, {
+            obj: objRef.value,
+            itemTransformer
+          });
+          mapToList(newValue, {
+            list: listRef.value,
+            itemTransformer
+          });
         },
         { deep: true, immediate: true }
       );
       const E = vue.computed(() => {
+        var _a;
         const result = {};
         if (!mapRef.value)
           return result;
         for (const key of mapRef.value.keys()) {
-          result[key] = key;
+          result[key] = (_a = transformer == null ? void 0 : transformer(key)) != null ? _a : key;
         }
         return result;
       });
@@ -257,7 +274,9 @@ function createDictManager(createDictManagerOptions = {}) {
       const reactiveCtx = vue.reactive(ctx);
       return vue.reactive({
         ...ctx,
+        // @ts-ignore
         ...managerExtra == null ? void 0 : managerExtra(reactiveCtx),
+        // @ts-ignore
         ...extra == null ? void 0 : extra(reactiveCtx)
       });
     }

package/dist/index.d.ts

@@ -1,3 +1 @@
-export type * from './types';
-export * from './dict-manager';
-export { defineDictData } from './util';
+export * from './vue';

package/dist/index.js

@@ -1,139 +1,13 @@
+import { warn, isFunction, cloneDeep, createPromise, mapToObj, mapToList, toMap, merge } from './chunk-SXX4ZFIR.js';
+export { defineDictData } from './chunk-SXX4ZFIR.js';
 import { reactive, readonly, shallowRef, toRef, ref, watch, computed } from 'vue';
 
-// src/dict-manager.ts
-
-// src/create-promise.ts
-var noop = () => {
-};
-function createPromise(executor) {
-  let resolve = noop;
-  let reject = noop;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-    executor == null ? void 0 : executor(_resolve, _reject);
-  });
-  promise.resolve = resolve;
-  promise.reject = reject;
-  promise.isPending = true;
-  promise.finally(() => {
-    promise.isPending = false;
-  });
-  return promise;
-}
-
-// src/util.ts
-function isFunction(fn) {
-  return typeof fn === "function";
-}
-function clearObj(obj) {
-  for (const key of Object.keys(obj)) {
-    delete obj[key];
-  }
-}
-function mapToObj(map, obj = {}) {
-  clearObj(obj);
-  for (const [key, value] of map) {
-    obj[key] = value;
-  }
-  return obj;
-}
-function checkObjItem(item, key, transformer) {
-  if (item.value === void 0) {
-    item.value = key;
-  }
-  if (isFunction(transformer)) {
-    item.value = transformer(item.value);
-  }
-}
-function mapToList(map, list = []) {
-  list.splice(0, list.length, ...map.values());
-  return list;
-}
-function listToMap(list) {
-  return new Map(list.map((item) => [item.value, item]));
-}
-function toMap(data, options = {}) {
-  const { pickValues = [], omitValues = [], transformer } = options;
-  const filterFn = (value) => (pickValues.length === 0 || pickValues.includes(value)) && !omitValues.includes(value);
-  if (Array.isArray(data)) {
-    return listToMap(data.filter((item) => filterFn(item.value)));
-  }
-  const map = /* @__PURE__ */ new Map();
-  Object.entries(data).filter(([key, item]) => {
-    checkObjItem(item, key, transformer);
-    return filterFn(item.value);
-  }).forEach(([, item]) => map.set(item.value, item));
-  return map;
-}
-var defineDictData = (data) => data;
-var { toString } = Object.prototype;
-function isPlainObject(obj) {
-  return toString.call(obj) === "[object Object]";
-}
-function merge(target, ...sources) {
-  if (!sources.length)
-    return target;
-  const source = sources.shift();
-  if (source && isPlainObject(source)) {
-    for (const key of Reflect.ownKeys(source)) {
-      const value = source[key];
-      if (isPlainObject(value)) {
-        if (!isPlainObject(target[key])) {
-          target[key] = {};
-        }
-        merge(target[key], value);
-      } else {
-        target[key] = value;
-      }
-    }
-  }
-  return merge(target, ...sources);
-}
-function cloneDeep(value) {
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(cloneDeep);
-  }
-  if (value instanceof Date) {
-    return new Date(value.getTime());
-  }
-  if (value instanceof RegExp) {
-    return new RegExp(value.source, value.flags);
-  }
-  if (value instanceof Map) {
-    const copy = /* @__PURE__ */ new Map();
-    value.forEach((val, key) => {
-      copy.set(cloneDeep(key), cloneDeep(val));
-    });
-    return copy;
-  }
-  if (value instanceof Set) {
-    const copy = /* @__PURE__ */ new Set();
-    value.forEach((val) => {
-      copy.add(cloneDeep(val));
-    });
-    return copy;
-  }
-  if (isPlainObject(value)) {
-    const copy = {};
-    for (const key of Reflect.ownKeys(value)) {
-      copy[key] = cloneDeep(value[key]);
-    }
-    return copy;
-  }
-  return value;
-}
-
-// src/dict-manager.ts
-var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
 function createDictManager(createDictManagerOptions = {}) {
   const {
     fetch: managerFetch,
     extra: managerExtra,
-    transformer: managerTransformer
+    transformer: managerTransformer,
+    itemTransformer: managerItemTransformer
   } = createDictManagerOptions;
   const maps = reactive(/* @__PURE__ */ Object.create(null));
   const defineDictOptionsMap = /* @__PURE__ */ new Map();
@@ -143,22 +17,29 @@ function createDictManager(createDictManagerOptions = {}) {
       (_a = maps[code]) == null ? void 0 : _a.clear();
       return;
     }
-    clearObj(maps);
+    Object.values(maps).forEach((map) => map.clear());
   }
   function _defineDict(defineDictInternalOptions, code, defineDictOptions) {
     const { pickValues, omitValues, extendCode } = defineDictInternalOptions;
     if (maps[code]) {
       warn(`code "${code}" already exists`);
+    } else {
+      maps[code] = /* @__PURE__ */ new Map();
     }
     const _defineDictOptions = Object.assign(
-      { data: {}, remote: false, fetch: managerFetch, transformer: managerTransformer },
+      {
+        data: {},
+        remote: false,
+        fetch: managerFetch,
+        transformer: managerTransformer,
+        itemTransformer: managerItemTransformer
+      },
       isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions
     );
     defineDictOptionsMap.set(code, cloneDeep(_defineDictOptions));
-    const { data, remote, fetch, extra, transformer } = _defineDictOptions;
-    const globalLoadPromise = shallowRef(null);
-    let loaded = false;
-    maps[code] = /* @__PURE__ */ new Map();
+    const { data, remote, fetch, extra, transformer, itemTransformer } = _defineDictOptions;
+    let globalLoadPromise = null;
+    let init = false;
     async function loadDict(options, mapRef) {
       var _a;
       const dataMap = toMap(cloneDeep(data), { pickValues, omitValues, transformer });
@@ -180,21 +61,23 @@ function createDictManager(createDictManagerOptions = {}) {
         useDictOptions
       );
       const { clone, immediate, refresh } = useDictOptions;
-      const loadPromise = !clone ? globalLoadPromise : shallowRef(createPromise());
-      const mapRef = !clone ? toRef(maps, code) : ref();
+      const loadPromise = shallowRef(
+        !clone ? globalLoadPromise : createPromise()
+      );
+      const mapRef = !clone ? toRef(maps, code) : ref(/* @__PURE__ */ new Map());
       const objRef = ref(/* @__PURE__ */ Object.create(null));
       const listRef = ref([]);
       if (!remote || immediate) {
         if (clone) {
           load();
         } else {
-          if (!globalLoadPromise.value) {
-            globalLoadPromise.value = createPromise();
+          if (!globalLoadPromise) {
+            globalLoadPromise = createPromise();
             load();
           } else {
-            globalLoadPromise.value.then(() => {
-              if (!loaded) {
-                loaded = true;
+            globalLoadPromise.then(() => {
+              if (!init) {
+                init = true;
                 load();
               } else if (refresh) {
                 load();
@@ -203,9 +86,9 @@ function createDictManager(createDictManagerOptions = {}) {
           }
         }
       } else {
-        if (!globalLoadPromise.value) {
-          globalLoadPromise.value = createPromise();
-          globalLoadPromise.value.resolve();
+        if (!globalLoadPromise) {
+          globalLoadPromise = createPromise();
+          globalLoadPromise.resolve();
         }
       }
       function load(options) {
@@ -218,24 +101,30 @@ function createDictManager(createDictManagerOptions = {}) {
         return loadPromise.value;
       }
       function _clear() {
-        var _a;
-        (_a = mapRef.value) == null ? void 0 : _a.clear();
+        mapRef.value.clear();
       }
       watch(
         mapRef,
         (newValue) => {
           newValue != null ? newValue : newValue = /* @__PURE__ */ new Map();
-          mapToObj(newValue, objRef.value);
-          mapToList(newValue, listRef.value);
+          mapToObj(newValue, {
+            obj: objRef.value,
+            itemTransformer
+          });
+          mapToList(newValue, {
+            list: listRef.value,
+            itemTransformer
+          });
         },
         { deep: true, immediate: true }
       );
       const E = computed(() => {
+        var _a;
         const result = {};
         if (!mapRef.value)
           return result;
         for (const key of mapRef.value.keys()) {
-          result[key] = key;
+          result[key] = (_a = transformer == null ? void 0 : transformer(key)) != null ? _a : key;
         }
         return result;
       });
@@ -255,7 +144,9 @@ function createDictManager(createDictManagerOptions = {}) {
       const reactiveCtx = reactive(ctx);
       return reactive({
         ...ctx,
+        // @ts-ignore
         ...managerExtra == null ? void 0 : managerExtra(reactiveCtx),
+        // @ts-ignore
         ...extra == null ? void 0 : extra(reactiveCtx)
       });
     }
@@ -270,4 +161,4 @@ function createDictManager(createDictManagerOptions = {}) {
   return { defineDict, clear, maps: readonly(maps) };
 }
 
-export { createDictManager, defineDictData };
+export { createDictManager };

package/dist/react/index.cjs

@@ -0,0 +1,308 @@
+'use strict';
+
+var react = require('react');
+
+// src/react/react-dict-manager.ts
+
+// src/create-promise.ts
+var noop = () => {
+};
+function createPromise(executor) {
+  let resolve = noop;
+  let reject = noop;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+    executor == null ? void 0 : executor(_resolve, _reject);
+  });
+  promise.resolve = resolve;
+  promise.reject = reject;
+  promise.isPending = true;
+  promise.finally(() => {
+    promise.isPending = false;
+  });
+  return promise;
+}
+
+// src/util.ts
+var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+function clearObj(obj) {
+  for (const key of Object.keys(obj)) {
+    delete obj[key];
+  }
+}
+function mapToObj(map, {
+  obj = {},
+  itemTransformer
+} = {}) {
+  var _a;
+  clearObj(obj);
+  for (const [key, value] of map) {
+    obj[key] = (_a = itemTransformer == null ? void 0 : itemTransformer(value)) != null ? _a : value;
+  }
+  return obj;
+}
+function checkObjItem(item, key, transformer) {
+  if (item.value === void 0) {
+    item.value = key;
+  }
+  if (isFunction(transformer)) {
+    item.value = transformer(item.value);
+  }
+}
+function mapToList(map, {
+  list = [],
+  itemTransformer
+} = {}) {
+  const values = isFunction(itemTransformer) ? map.values().map(itemTransformer) : map.values();
+  list.splice(0, list.length, ...values);
+  return list;
+}
+function toMap(data, { map = /* @__PURE__ */ new Map(), pickValues = [], omitValues = [], transformer } = {}) {
+  const filterFn = (value) => (pickValues.length === 0 || pickValues.includes(value)) && !omitValues.includes(value);
+  map.clear();
+  Object.entries(data).filter(([key, item]) => {
+    checkObjItem(item, key, transformer);
+    return filterFn(item.value);
+  }).forEach(([, item]) => map.set(item.value, item));
+  return map;
+}
+var defineDictData = (data) => data;
+var { toString } = Object.prototype;
+function isPlainObject(obj) {
+  return toString.call(obj) === "[object Object]";
+}
+function merge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source && isPlainObject(source)) {
+    for (const key of Reflect.ownKeys(source)) {
+      const value = source[key];
+      if (isPlainObject(value)) {
+        if (!isPlainObject(target[key])) {
+          target[key] = {};
+        }
+        merge(target[key], value);
+      } else {
+        target[key] = value;
+      }
+    }
+  }
+  return merge(target, ...sources);
+}
+function cloneDeep(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(cloneDeep);
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+  if (value instanceof Map) {
+    const copy = /* @__PURE__ */ new Map();
+    value.forEach((val, key) => {
+      copy.set(cloneDeep(key), cloneDeep(val));
+    });
+    return copy;
+  }
+  if (value instanceof Set) {
+    const copy = /* @__PURE__ */ new Set();
+    value.forEach((val) => {
+      copy.add(cloneDeep(val));
+    });
+    return copy;
+  }
+  if (isPlainObject(value)) {
+    const copy = {};
+    for (const key of Reflect.ownKeys(value)) {
+      copy[key] = cloneDeep(value[key]);
+    }
+    return copy;
+  }
+  return value;
+}
+
+// src/react/react-dict-manager.ts
+function createDictManager(createDictManagerOptions = {}) {
+  const {
+    fetch: managerFetch,
+    extra: managerExtra,
+    transformer: managerTransformer,
+    itemTransformer: managerItemTransformer
+  } = createDictManagerOptions;
+  const defineDictOptionsMap = /* @__PURE__ */ new Map();
+  const maps = /* @__PURE__ */ Object.create(null);
+  const versionMap = /* @__PURE__ */ Object.create(null);
+  function clear(code) {
+    var _a;
+    if (code) {
+      (_a = maps[code]) == null ? void 0 : _a.clear();
+      return;
+    }
+    Object.values(maps).forEach((map) => map.clear());
+  }
+  function _defineDict(defineDictInternalOptions, code, defineDictOptions) {
+    const { pickValues, omitValues, extendCode } = defineDictInternalOptions;
+    if (maps[code]) {
+      warn(`code "${code}" already exists`);
+    } else {
+      maps[code] = /* @__PURE__ */ new Map();
+      versionMap[code] = 0;
+    }
+    const _defineDictOptions = Object.assign(
+      {
+        data: {},
+        remote: false,
+        fetch: managerFetch,
+        transformer: managerTransformer,
+        itemTransformer: managerItemTransformer
+      },
+      isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions
+    );
+    defineDictOptionsMap.set(code, cloneDeep(_defineDictOptions));
+    const { data, remote, fetch, extra, transformer, itemTransformer } = _defineDictOptions;
+    let globalLoadPromise = null;
+    let init = false;
+    async function loadDict(options, mapRef) {
+      var _a;
+      if (remote) {
+        const res = (_a = await (fetch == null ? void 0 : fetch(extendCode != null ? extendCode : code, options))) != null ? _a : [];
+        toMap(res, { pickValues, omitValues, transformer, map: mapRef.current });
+        toMap(cloneDeep(data), { pickValues, omitValues, transformer }).forEach(
+          (value, key) => {
+            if (mapRef.current.has(key)) {
+              merge(mapRef.current.get(key), value);
+            }
+          }
+        );
+      } else {
+        toMap(cloneDeep(data), { pickValues, omitValues, transformer, map: mapRef.current });
+      }
+      versionMap[code] += 1;
+    }
+    function useDict(useDictOptions = {}) {
+      const mergedOptions = {
+        clone: false,
+        immediate: true,
+        refresh: false,
+        ...useDictOptions
+      };
+      const { clone, immediate, refresh } = mergedOptions;
+      const loadPromiseRef = react.useRef(
+        !clone ? globalLoadPromise : createPromise()
+      );
+      const mapRef = react.useRef(!clone ? maps[code] : /* @__PURE__ */ new Map());
+      const versionRef = react.useRef(0);
+      const getStateFromMapRef = () => {
+        const newObj = /* @__PURE__ */ Object.create(null);
+        const newList = [];
+        mapToObj(mapRef.current, {
+          obj: newObj,
+          itemTransformer
+        });
+        mapToList(mapRef.current, {
+          list: newList,
+          itemTransformer
+        });
+        const newE = Object.fromEntries(
+          Array.from(mapRef.current.keys()).map((key) => {
+            var _a;
+            return [key, (_a = transformer == null ? void 0 : transformer(key)) != null ? _a : key];
+          })
+        );
+        return {
+          map: newObj,
+          list: newList,
+          E: newE
+        };
+      };
+      const [state, setState] = react.useState(getStateFromMapRef());
+      if (versionRef.current !== versionMap[code]) {
+        versionRef.current = versionMap[code];
+        setState(getStateFromMapRef());
+      }
+      const load = react.useCallback((options) => {
+        const oldLoadPromise = loadPromiseRef.current;
+        loadPromiseRef.current = createPromise();
+        loadDict({ ...mergedOptions, ...options }, mapRef).then(() => {
+          setState(getStateFromMapRef());
+          oldLoadPromise == null ? void 0 : oldLoadPromise.resolve(void 0);
+          loadPromiseRef.current.resolve(void 0);
+        });
+        return loadPromiseRef.current;
+      }, []);
+      const clear2 = react.useCallback(() => {
+        mapRef.current.clear();
+        setState(getStateFromMapRef());
+      }, []);
+      const getItem = react.useCallback((value) => {
+        return value !== null && value !== void 0 ? mapRef.current.get(value) : null;
+      }, []);
+      react.useEffect(() => {
+        if (!remote || immediate) {
+          if (clone) {
+            load();
+          } else {
+            if (!globalLoadPromise) {
+              globalLoadPromise = createPromise();
+              load();
+            } else {
+              globalLoadPromise.then(() => {
+                if (!init) {
+                  init = true;
+                  load();
+                } else if (refresh) {
+                  load();
+                }
+              });
+            }
+          }
+        } else {
+          if (!globalLoadPromise) {
+            globalLoadPromise = createPromise();
+            globalLoadPromise.resolve(void 0);
+          }
+        }
+      }, []);
+      const ctx = react.useMemo(() => {
+        const _ctx = {
+          map: state.map,
+          list: state.list,
+          E: state.E,
+          loadPromise: loadPromiseRef.current,
+          load,
+          getItem,
+          clear: clear2
+        };
+        return {
+          ..._ctx,
+          // @ts-ignore
+          ...managerExtra == null ? void 0 : managerExtra(_ctx),
+          // @ts-ignore
+          ...extra == null ? void 0 : extra(_ctx)
+        };
+      }, [state]);
+      return ctx;
+    }
+    useDict.extend = (extendCode2, extendOptions) => {
+      const { pickValues: pickValues2, omitValues: omitValues2 } = extendOptions != null ? extendOptions : {};
+      const options = defineDictOptionsMap.get(code);
+      return _defineDict({ pickValues: pickValues2, omitValues: omitValues2, extendCode: code }, extendCode2, options);
+    };
+    return useDict;
+  }
+  const defineDict = _defineDict.bind(null, {});
+  return { defineDict, clear, maps };
+}
+
+exports.createDictManager = createDictManager;
+exports.defineDictData = defineDictData;

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export type * from '../types';
+export * from './react-dict-manager';
+export { defineDictData } from '../util';

package/dist/react/index.js

@@ -0,0 +1,177 @@
+import { warn, isFunction, cloneDeep, createPromise, toMap, merge, mapToObj, mapToList } from '../chunk-SXX4ZFIR.js';
+export { defineDictData } from '../chunk-SXX4ZFIR.js';
+import { useRef, useState, useCallback, useEffect, useMemo } from 'react';
+
+function createDictManager(createDictManagerOptions = {}) {
+  const {
+    fetch: managerFetch,
+    extra: managerExtra,
+    transformer: managerTransformer,
+    itemTransformer: managerItemTransformer
+  } = createDictManagerOptions;
+  const defineDictOptionsMap = /* @__PURE__ */ new Map();
+  const maps = /* @__PURE__ */ Object.create(null);
+  const versionMap = /* @__PURE__ */ Object.create(null);
+  function clear(code) {
+    var _a;
+    if (code) {
+      (_a = maps[code]) == null ? void 0 : _a.clear();
+      return;
+    }
+    Object.values(maps).forEach((map) => map.clear());
+  }
+  function _defineDict(defineDictInternalOptions, code, defineDictOptions) {
+    const { pickValues, omitValues, extendCode } = defineDictInternalOptions;
+    if (maps[code]) {
+      warn(`code "${code}" already exists`);
+    } else {
+      maps[code] = /* @__PURE__ */ new Map();
+      versionMap[code] = 0;
+    }
+    const _defineDictOptions = Object.assign(
+      {
+        data: {},
+        remote: false,
+        fetch: managerFetch,
+        transformer: managerTransformer,
+        itemTransformer: managerItemTransformer
+      },
+      isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions
+    );
+    defineDictOptionsMap.set(code, cloneDeep(_defineDictOptions));
+    const { data, remote, fetch, extra, transformer, itemTransformer } = _defineDictOptions;
+    let globalLoadPromise = null;
+    let init = false;
+    async function loadDict(options, mapRef) {
+      var _a;
+      if (remote) {
+        const res = (_a = await (fetch == null ? void 0 : fetch(extendCode != null ? extendCode : code, options))) != null ? _a : [];
+        toMap(res, { pickValues, omitValues, transformer, map: mapRef.current });
+        toMap(cloneDeep(data), { pickValues, omitValues, transformer }).forEach(
+          (value, key) => {
+            if (mapRef.current.has(key)) {
+              merge(mapRef.current.get(key), value);
+            }
+          }
+        );
+      } else {
+        toMap(cloneDeep(data), { pickValues, omitValues, transformer, map: mapRef.current });
+      }
+      versionMap[code] += 1;
+    }
+    function useDict(useDictOptions = {}) {
+      const mergedOptions = {
+        clone: false,
+        immediate: true,
+        refresh: false,
+        ...useDictOptions
+      };
+      const { clone, immediate, refresh } = mergedOptions;
+      const loadPromiseRef = useRef(
+        !clone ? globalLoadPromise : createPromise()
+      );
+      const mapRef = useRef(!clone ? maps[code] : /* @__PURE__ */ new Map());
+      const versionRef = useRef(0);
+      const getStateFromMapRef = () => {
+        const newObj = /* @__PURE__ */ Object.create(null);
+        const newList = [];
+        mapToObj(mapRef.current, {
+          obj: newObj,
+          itemTransformer
+        });
+        mapToList(mapRef.current, {
+          list: newList,
+          itemTransformer
+        });
+        const newE = Object.fromEntries(
+          Array.from(mapRef.current.keys()).map((key) => {
+            var _a;
+            return [key, (_a = transformer == null ? void 0 : transformer(key)) != null ? _a : key];
+          })
+        );
+        return {
+          map: newObj,
+          list: newList,
+          E: newE
+        };
+      };
+      const [state, setState] = useState(getStateFromMapRef());
+      if (versionRef.current !== versionMap[code]) {
+        versionRef.current = versionMap[code];
+        setState(getStateFromMapRef());
+      }
+      const load = useCallback((options) => {
+        const oldLoadPromise = loadPromiseRef.current;
+        loadPromiseRef.current = createPromise();
+        loadDict({ ...mergedOptions, ...options }, mapRef).then(() => {
+          setState(getStateFromMapRef());
+          oldLoadPromise == null ? void 0 : oldLoadPromise.resolve(void 0);
+          loadPromiseRef.current.resolve(void 0);
+        });
+        return loadPromiseRef.current;
+      }, []);
+      const clear2 = useCallback(() => {
+        mapRef.current.clear();
+        setState(getStateFromMapRef());
+      }, []);
+      const getItem = useCallback((value) => {
+        return value !== null && value !== void 0 ? mapRef.current.get(value) : null;
+      }, []);
+      useEffect(() => {
+        if (!remote || immediate) {
+          if (clone) {
+            load();
+          } else {
+            if (!globalLoadPromise) {
+              globalLoadPromise = createPromise();
+              load();
+            } else {
+              globalLoadPromise.then(() => {
+                if (!init) {
+                  init = true;
+                  load();
+                } else if (refresh) {
+                  load();
+                }
+              });
+            }
+          }
+        } else {
+          if (!globalLoadPromise) {
+            globalLoadPromise = createPromise();
+            globalLoadPromise.resolve(void 0);
+          }
+        }
+      }, []);
+      const ctx = useMemo(() => {
+        const _ctx = {
+          map: state.map,
+          list: state.list,
+          E: state.E,
+          loadPromise: loadPromiseRef.current,
+          load,
+          getItem,
+          clear: clear2
+        };
+        return {
+          ..._ctx,
+          // @ts-ignore
+          ...managerExtra == null ? void 0 : managerExtra(_ctx),
+          // @ts-ignore
+          ...extra == null ? void 0 : extra(_ctx)
+        };
+      }, [state]);
+      return ctx;
+    }
+    useDict.extend = (extendCode2, extendOptions) => {
+      const { pickValues: pickValues2, omitValues: omitValues2 } = extendOptions != null ? extendOptions : {};
+      const options = defineDictOptionsMap.get(code);
+      return _defineDict({ pickValues: pickValues2, omitValues: omitValues2, extendCode: code }, extendCode2, options);
+    };
+    return useDict;
+  }
+  const defineDict = _defineDict.bind(null, {});
+  return { defineDict, clear, maps };
+}
+
+export { createDictManager };

package/dist/react/react-dict-manager.d.ts

@@ -0,0 +1,6 @@
+import type { CreateDictManagerOptions, DefineDict, DictMap, ExtraGetter, Fetch, Recordable } from '../types';
+export declare function createDictManager<E extends ExtraGetter, F extends Fetch>(createDictManagerOptions?: CreateDictManagerOptions<E, F>): {
+    defineDict: DefineDict<E, F>;
+    clear: (code?: string) => void;
+    maps: Recordable<DictMap>;
+};

package/dist/types/dict.d.ts

@@ -22,13 +22,14 @@ export type Dict<K extends PropertyKey = PropertyKey, I extends Recordable = Dic
     clear: () => void;
     getItem: (value?: I['value'] | Nil) => I | Nil;
 };
-export type Fetch = (code: string, options?: Recordable) => MaybePromise<DictItemRecord[]>;
+export type Fetch = (code: string, options: Recordable) => MaybePromise<DictItemRecord[]>;
 type FetchOptions<F extends Fetch> = Parameters<F>[1] extends infer T ? T extends Nil ? {} : T : {};
 export type ExtraGetter<D extends Dict<string> = Dict<string>> = (dict: D) => Recordable;
 export interface CreateDictManagerOptions<E extends ExtraGetter, F extends Fetch> {
     fetch?: F;
     extra?: E;
     transformer?: (value: DictValue) => DictValue;
+    itemTransformer?: (item: DictItemRecord) => any;
 }
 export type UseDictOptions = {
     clone?: boolean;
@@ -56,7 +57,8 @@ export interface DefineDict<ME extends ExtraGetter, MF extends Fetch> {
         data?: D;
         extra?: E;
         transformer?: (value: DictValue) => DictValue;
-    }>): UseDict<ReturnType<ME> & ReturnType<E>, D, MF>;
+        itemTransformer?: (item: DictItemRecord) => any;
+    }>): UseDict<ReturnType<ME> & ReturnType<E>, D, F extends undefined ? MF : F>;
 }
 export type VDictItem<T extends AnyFn> = ReturnType<T> extends {
     list: Array<infer R>;

package/dist/util.d.ts

@@ -1,15 +1,22 @@
 import type { AnyFn, DictItemRecord, DictMap, DictValue, Merge, PlainObject, Recordable } from './types';
+export declare const warn: (msg: string) => void;
 export declare function isFunction(fn: unknown): fn is AnyFn;
 export declare function clearObj(obj: Recordable): void;
-export declare function mapToObj(map: DictMap, obj?: Recordable<DictItemRecord>): Recordable<DictItemRecord>;
-export declare function mapToList(map: DictMap, list?: DictItemRecord[]): DictItemRecord[];
-export declare function listToMap(list: DictItemRecord[]): Map<DictValue, DictItemRecord>;
+export declare function mapToObj(map: DictMap, { obj, itemTransformer }?: {
+    obj?: Recordable<DictItemRecord>;
+    itemTransformer?: (item: DictItemRecord) => any;
+}): Recordable<DictItemRecord>;
+export declare function mapToList(map: DictMap, { list, itemTransformer }?: {
+    list?: DictItemRecord[];
+    itemTransformer?: (item: DictItemRecord) => any;
+}): DictItemRecord[];
 type MapOptions = {
+    map?: DictMap;
     pickValues?: DictValue[];
     omitValues?: DictValue[];
     transformer?: (value: DictValue) => DictValue;
 };
-export declare function toMap(data: Recordable<DictItemRecord> | DictItemRecord[], options?: MapOptions): DictMap;
+export declare function toMap(data: Recordable<DictItemRecord> | DictItemRecord[], { map, pickValues, omitValues, transformer }?: MapOptions): DictMap;
 export declare const defineDictData: <T>(data: T) => T;
 export declare function isPlainObject(obj: any): obj is PlainObject;
 export declare function merge<T extends PlainObject, S extends PlainObject[]>(target: T, ...sources: S): Merge<[T, ...S]>;

package/dist/vue/index.d.ts

@@ -0,0 +1,3 @@
+export type * from '../types';
+export * from './vue-dict-manager';
+export { defineDictData } from '../util';

package/dist/{dict-manager.d.ts → vue/vue-dict-manager.d.ts}

@@ -1,4 +1,4 @@
-import type { CreateDictManagerOptions, DefineDict, DictValue, ExtraGetter, Fetch } from './types';
+import type { CreateDictManagerOptions, DefineDict, DictValue, ExtraGetter, Fetch } from '../types';
 export declare function createDictManager<E extends ExtraGetter, F extends Fetch>(createDictManagerOptions?: CreateDictManagerOptions<E, F>): {
     defineDict: DefineDict<E, F>;
     clear: (code?: string) => void;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "v-dict",
-  "version": "1.2.10",
+  "version": "2.0.0",
   "type": "module",
-  "description": "Vue3 Dict Manager",
+  "description": "Vue3 & React Dict Manager",
   "repository": {
     "type": "git",
     "url": "https://github.com/xuuui/v-dict"
@@ -14,7 +14,12 @@
     ".": {
       "import": "./dist/index.js",
       "require": "./dist/index.cjs",
-      "types": "./lib/index.d.ts"
+      "types": "./dist/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react/index.js",
+      "require": "./dist/react/index.cjs",
+      "types": "./dist/react/index.d.ts"
     },
     "./*": "./*"
   },
@@ -32,19 +37,25 @@
   },
   "keywords": [
     "vue",
+    "react",
     "dict",
     "dictionary",
-    "vue3"
+    "vue3",
+    "react-dict"
   ],
   "author": "",
   "license": "MIT",
   "dependencies": {},
   "peerDependencies": {
-    "vue": "^3.0.0"
+    "vue": "^3.0.0",
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0"
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.1",
     "@types/node": "^20.11.0",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
     "tsup": "^8.0.1",
     "typescript": "^5.7.3",
     "vue": "^3.4.10"