v-dict 1.1.2 → 1.2.0

package/dist/dict-manager.d.ts

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

package/dist/index.cjs

@@ -38,11 +38,12 @@ function mapToObj(map, obj = {}) {
 }
 function objToMap(obj) {
   const map = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(obj)) {
-    if (lodashEs.isUndefined(value.value)) {
-      value.value = key;
+  for (const key of Object.keys(obj)) {
+    const item = obj[key];
+    if (lodashEs.isUndefined(item.value)) {
+      item.value = key;
     }
-    map.set(key, value);
+    map.set(key, item);
   }
   return map;
 }
@@ -58,39 +59,62 @@ function listToMap(list) {
   }
   return map;
 }
-function toMap(data) {
-  return lodashEs.isArray(data) ? listToMap(data) : objToMap(data);
+function toMap(data, {
+  pickValues,
+  omitValues
+} = {}) {
+  if (lodashEs.isArray(data)) {
+    if (pickValues == null ? void 0 : pickValues.length) {
+      data = data.filter((item) => pickValues.includes(item.value));
+    }
+    if (omitValues == null ? void 0 : omitValues.length) {
+      data = data.filter((item) => !omitValues.includes(item.value));
+    }
+    return listToMap(data);
+  }
+  if (pickValues == null ? void 0 : pickValues.length) {
+    data = lodashEs.pick(data, ...pickValues);
+  }
+  if (omitValues == null ? void 0 : omitValues.length) {
+    data = lodashEs.omit(data, ...omitValues);
+  }
+  return objToMap(data);
 }
 var defineDictData = (data) => data;
 
 // src/dict-manager.ts
+var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
 function createDictManager(managerOptions = {}) {
   const { fetch: managerFetch, extra: managerExtra } = managerOptions;
-  const maps = vue.reactive({});
+  const maps = vue.reactive(/* @__PURE__ */ Object.create(null));
+  const defineDictOptionsMap = /* @__PURE__ */ new Map();
   function clear(code) {
+    var _a;
     if (code) {
-      const dictMap = maps[code];
-      dictMap && dictMap.clear();
+      (_a = maps[code]) == null ? void 0 : _a.clear();
       return;
     }
     clearObj(maps);
   }
-  const defineDict = (code, defineDictOptions) => {
-    var _a;
-    const {
-      data = {},
-      remote = false,
-      fetch = managerFetch,
-      extra
-    } = (_a = lodashEs.isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions) != null ? _a : {};
+  function _defineDict(internalOptions, code, defineDictOptions) {
+    if (maps[code]) {
+      warn(`code "${code}" already exists`);
+    }
+    const { pickValues, omitValues } = internalOptions;
+    const options = Object.assign(
+      { data: {}, remote: false, fetch: managerFetch },
+      lodashEs.isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions
+    );
+    defineDictOptionsMap.set(code, options);
+    const { data, remote, fetch, extra } = options;
     const globalLoadPromise = vue.shallowRef(null);
     maps[code] = /* @__PURE__ */ new Map();
-    async function loadDict(options, mapRef) {
-      var _a2;
-      const dataMap = toMap(lodashEs.cloneDeep(data));
+    async function loadDict(options2, mapRef) {
+      var _a;
+      const dataMap = toMap(lodashEs.cloneDeep(data), { pickValues, omitValues });
       if (remote) {
-        const res = (_a2 = await (fetch == null ? void 0 : fetch(code, options))) != null ? _a2 : [];
-        mapRef.value = toMap(res);
+        const res = (_a = await (fetch == null ? void 0 : fetch(code, options2))) != null ? _a : [];
+        mapRef.value = toMap(res, { pickValues, omitValues });
         dataMap.forEach((value, key) => {
           if (mapRef.value.has(key)) {
             lodashEs.merge(mapRef.value.get(key), value);
@@ -100,28 +124,16 @@ function createDictManager(managerOptions = {}) {
         mapRef.value = dataMap;
       }
     }
-    return (useDictOptions) => {
-      useDictOptions = lodashEs.merge({ clone: false, immediate: true, refresh: false }, useDictOptions);
+    function useDict(useDictOptions) {
+      useDictOptions = Object.assign(
+        { clone: false, immediate: true, refresh: false },
+        useDictOptions
+      );
       const { clone, immediate, refresh } = useDictOptions;
       const loadPromise = !clone ? globalLoadPromise : vue.shallowRef(createPromise());
       const mapRef = !clone ? vue.toRef(maps, code) : vue.ref(/* @__PURE__ */ new Map());
-      const objRef = vue.ref({});
+      const objRef = vue.ref(/* @__PURE__ */ Object.create(null));
       const listRef = vue.ref([]);
-      vue.watch(
-        mapRef,
-        (newValue) => {
-          mapToObj(newValue, objRef.value);
-          mapToList(newValue, listRef.value);
-        },
-        { deep: true, immediate: true }
-      );
-      const E = vue.computed(() => {
-        const result = {};
-        for (const key of mapRef.value.keys()) {
-          result[key] = key;
-        }
-        return result;
-      });
       if (!remote || immediate) {
         if (clone) {
           load();
@@ -140,10 +152,10 @@ function createDictManager(managerOptions = {}) {
           globalLoadPromise.value = createPromise();
         }
       }
-      function load(options) {
+      function load(options2) {
         const oldLoadPromise = loadPromise.value;
         loadPromise.value = createPromise();
-        loadDict(lodashEs.merge({}, useDictOptions, options), mapRef).then(() => {
+        loadDict(Object.assign({}, useDictOptions, options2), mapRef).then(() => {
           oldLoadPromise.resolve();
           loadPromise.value.resolve();
         });
@@ -152,6 +164,21 @@ function createDictManager(managerOptions = {}) {
       function _clear() {
         mapRef.value.clear();
       }
+      vue.watch(
+        mapRef,
+        (newValue) => {
+          mapToObj(newValue, objRef.value);
+          mapToList(newValue, listRef.value);
+        },
+        { deep: true, immediate: true }
+      );
+      const E = vue.computed(() => {
+        const result = {};
+        for (const key of mapRef.value.keys()) {
+          result[key] = key;
+        }
+        return result;
+      });
       const ctx = {
         map: objRef,
         list: listRef,
@@ -166,8 +193,16 @@ function createDictManager(managerOptions = {}) {
         ...managerExtra == null ? void 0 : managerExtra(reactiveCtx),
         ...extra == null ? void 0 : extra(reactiveCtx)
       });
+    }
+    const dictCode = code;
+    useDict.extend = (code2, extendOptions) => {
+      const { pickValues: pickValues2, omitValues: omitValues2 } = extendOptions != null ? extendOptions : {};
+      const options2 = defineDictOptionsMap.get(dictCode);
+      return _defineDict.bind(null, { pickValues: pickValues2, omitValues: omitValues2 }, code2, options2);
     };
-  };
+    return useDict;
+  }
+  const defineDict = _defineDict.bind(null, {});
   return { defineDict, clear };
 }
 

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,5 @@
 import { reactive, shallowRef, toRef, ref, watch, computed } from 'vue';
-import { isFunction, merge, cloneDeep, isArray, isUndefined } from 'lodash-es';
+import { isFunction, cloneDeep, merge, isArray, pick, omit, isUndefined } from 'lodash-es';
 
 // src/dict-manager.ts
 
@@ -36,11 +36,12 @@ function mapToObj(map, obj = {}) {
 }
 function objToMap(obj) {
   const map = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(obj)) {
-    if (isUndefined(value.value)) {
-      value.value = key;
+  for (const key of Object.keys(obj)) {
+    const item = obj[key];
+    if (isUndefined(item.value)) {
+      item.value = key;
     }
-    map.set(key, value);
+    map.set(key, item);
   }
   return map;
 }
@@ -56,39 +57,62 @@ function listToMap(list) {
   }
   return map;
 }
-function toMap(data) {
-  return isArray(data) ? listToMap(data) : objToMap(data);
+function toMap(data, {
+  pickValues,
+  omitValues
+} = {}) {
+  if (isArray(data)) {
+    if (pickValues == null ? void 0 : pickValues.length) {
+      data = data.filter((item) => pickValues.includes(item.value));
+    }
+    if (omitValues == null ? void 0 : omitValues.length) {
+      data = data.filter((item) => !omitValues.includes(item.value));
+    }
+    return listToMap(data);
+  }
+  if (pickValues == null ? void 0 : pickValues.length) {
+    data = pick(data, ...pickValues);
+  }
+  if (omitValues == null ? void 0 : omitValues.length) {
+    data = omit(data, ...omitValues);
+  }
+  return objToMap(data);
 }
 var defineDictData = (data) => data;
 
 // src/dict-manager.ts
+var warn = (msg) => console.warn(`[v-dict]: ${msg}`);
 function createDictManager(managerOptions = {}) {
   const { fetch: managerFetch, extra: managerExtra } = managerOptions;
-  const maps = reactive({});
+  const maps = reactive(/* @__PURE__ */ Object.create(null));
+  const defineDictOptionsMap = /* @__PURE__ */ new Map();
   function clear(code) {
+    var _a;
     if (code) {
-      const dictMap = maps[code];
-      dictMap && dictMap.clear();
+      (_a = maps[code]) == null ? void 0 : _a.clear();
       return;
     }
     clearObj(maps);
   }
-  const defineDict = (code, defineDictOptions) => {
-    var _a;
-    const {
-      data = {},
-      remote = false,
-      fetch = managerFetch,
-      extra
-    } = (_a = isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions) != null ? _a : {};
+  function _defineDict(internalOptions, code, defineDictOptions) {
+    if (maps[code]) {
+      warn(`code "${code}" already exists`);
+    }
+    const { pickValues, omitValues } = internalOptions;
+    const options = Object.assign(
+      { data: {}, remote: false, fetch: managerFetch },
+      isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions
+    );
+    defineDictOptionsMap.set(code, options);
+    const { data, remote, fetch, extra } = options;
     const globalLoadPromise = shallowRef(null);
     maps[code] = /* @__PURE__ */ new Map();
-    async function loadDict(options, mapRef) {
-      var _a2;
-      const dataMap = toMap(cloneDeep(data));
+    async function loadDict(options2, mapRef) {
+      var _a;
+      const dataMap = toMap(cloneDeep(data), { pickValues, omitValues });
       if (remote) {
-        const res = (_a2 = await (fetch == null ? void 0 : fetch(code, options))) != null ? _a2 : [];
-        mapRef.value = toMap(res);
+        const res = (_a = await (fetch == null ? void 0 : fetch(code, options2))) != null ? _a : [];
+        mapRef.value = toMap(res, { pickValues, omitValues });
         dataMap.forEach((value, key) => {
           if (mapRef.value.has(key)) {
             merge(mapRef.value.get(key), value);
@@ -98,28 +122,16 @@ function createDictManager(managerOptions = {}) {
         mapRef.value = dataMap;
       }
     }
-    return (useDictOptions) => {
-      useDictOptions = merge({ clone: false, immediate: true, refresh: false }, useDictOptions);
+    function useDict(useDictOptions) {
+      useDictOptions = Object.assign(
+        { clone: false, immediate: true, refresh: false },
+        useDictOptions
+      );
       const { clone, immediate, refresh } = useDictOptions;
       const loadPromise = !clone ? globalLoadPromise : shallowRef(createPromise());
       const mapRef = !clone ? toRef(maps, code) : ref(/* @__PURE__ */ new Map());
-      const objRef = ref({});
+      const objRef = ref(/* @__PURE__ */ Object.create(null));
       const listRef = ref([]);
-      watch(
-        mapRef,
-        (newValue) => {
-          mapToObj(newValue, objRef.value);
-          mapToList(newValue, listRef.value);
-        },
-        { deep: true, immediate: true }
-      );
-      const E = computed(() => {
-        const result = {};
-        for (const key of mapRef.value.keys()) {
-          result[key] = key;
-        }
-        return result;
-      });
       if (!remote || immediate) {
         if (clone) {
           load();
@@ -138,10 +150,10 @@ function createDictManager(managerOptions = {}) {
           globalLoadPromise.value = createPromise();
         }
       }
-      function load(options) {
+      function load(options2) {
         const oldLoadPromise = loadPromise.value;
         loadPromise.value = createPromise();
-        loadDict(merge({}, useDictOptions, options), mapRef).then(() => {
+        loadDict(Object.assign({}, useDictOptions, options2), mapRef).then(() => {
           oldLoadPromise.resolve();
           loadPromise.value.resolve();
         });
@@ -150,6 +162,21 @@ function createDictManager(managerOptions = {}) {
       function _clear() {
         mapRef.value.clear();
       }
+      watch(
+        mapRef,
+        (newValue) => {
+          mapToObj(newValue, objRef.value);
+          mapToList(newValue, listRef.value);
+        },
+        { deep: true, immediate: true }
+      );
+      const E = computed(() => {
+        const result = {};
+        for (const key of mapRef.value.keys()) {
+          result[key] = key;
+        }
+        return result;
+      });
       const ctx = {
         map: objRef,
         list: listRef,
@@ -164,8 +191,16 @@ function createDictManager(managerOptions = {}) {
         ...managerExtra == null ? void 0 : managerExtra(reactiveCtx),
         ...extra == null ? void 0 : extra(reactiveCtx)
       });
+    }
+    const dictCode = code;
+    useDict.extend = (code2, extendOptions) => {
+      const { pickValues: pickValues2, omitValues: omitValues2 } = extendOptions != null ? extendOptions : {};
+      const options2 = defineDictOptionsMap.get(dictCode);
+      return _defineDict.bind(null, { pickValues: pickValues2, omitValues: omitValues2 }, code2, options2);
     };
-  };
+    return useDict;
+  }
+  const defineDict = _defineDict.bind(null, {});
   return { defineDict, clear };
 }
 

package/dist/types/dict.d.ts

@@ -0,0 +1,64 @@
+import type { Merge, Simplify, ValueOf } from 'type-fest';
+import type { createPromise } from '../create-promise';
+import type { MergeUnionObject } from './util';
+export type DictItem = {
+    label: string;
+    value: string;
+};
+export type DictItemRecord = {
+    label: string;
+    value: string;
+    [x: string]: any;
+};
+export type DictMap = Map<string, DictItemRecord>;
+export type Fetch = (code: string, options?: any) => MaybePromise<DictItemRecord[]>;
+export interface CreateDictManager<E extends ExtraGetter> {
+    fetch?: Fetch;
+    extra?: E;
+}
+export type ExtraGetter<D extends Dict<string> = Dict<string>> = (dict: D) => Recordable;
+export type UseDictOptions = {
+    clone?: boolean;
+    immediate?: boolean;
+    refresh?: boolean;
+    [x: string]: any;
+};
+type ExtractFetchOptions<F extends Fetch> = Parameters<F>[1] extends infer T ? T extends undefined ? {} : T : never;
+type ExtractFetchReturn<F extends Fetch> = UnwrapArray<Awaited<ReturnType<F>>> extends infer Item ? Item extends never ? {} : Item : never;
+type _UseDict<ME extends ExtraGetter, E extends ExtraGetter, D extends Recordable, F extends Fetch> = (options?: Simplify<UseDictOptions & ExtractFetchOptions<F>>) => Simplify<CreateDict<D, F> & ReturnType<ME> & ReturnType<E>>;
+type UseDict<ME extends ExtraGetter, E extends ExtraGetter, D extends Recordable, F extends Fetch> = _UseDict<ME, E, D, F> & {
+    extend: (code: string, extendOptions?: {
+        pickValues?: Simplify<keyof D>[];
+        omitValues?: Simplify<keyof D>[];
+    }) => UseDict<ME, E, D, F>;
+};
+export interface DefineDict<ME extends ExtraGetter> {
+    <R extends boolean, F extends Fetch, D extends Recordable<{
+        label: string;
+        [x: string]: any;
+    }>, E extends ExtraGetter>(code: string, options?: MaybeGetter<{
+        remote?: R;
+        fetch?: F;
+        data?: D;
+        extra?: E;
+    }>): UseDict<ME, E, D, F>;
+}
+type CreateDict<D extends Recordable<Recordable>, F extends Fetch> = Dict<keyof D, Merge<ExtractFetchReturn<F>, MergeUnionObject<ValueOf<D>>>, UseDictOptions & ExtractFetchOptions<F>>;
+export type LoadPromise = ReturnType<typeof createPromise<void>>;
+export type Dict<Key extends PropertyKey = PropertyKey, Item extends Recordable = DictItem, Options = Recordable> = {
+    list: Simplify<{
+        value: string;
+    } & Item>[];
+    E: {
+        [K in Key]: K;
+    };
+    map: {
+        [K in Key]: Simplify<{
+            value: string;
+        } & Item>;
+    };
+    loadPromise: LoadPromise;
+    load: (options?: Options) => LoadPromise;
+    clear: () => void;
+};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './dict';

package/dist/types/util.d.ts

@@ -0,0 +1,12 @@
+import type { Merge, Simplify } from 'type-fest';
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T extends object> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+type Push<T extends any[], V> = [...T, V];
+type UnionToTuple<T extends object, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+type MissingProperties<T, U> = Exclude<keyof T, keyof U>;
+type CompareDataWithTarget<Data extends any[], Target> = {
+    [K in keyof Data]: MissingProperties<Target, Data[K]>;
+};
+type ExtractOptionalKey<T extends object> = CompareDataWithTarget<UnionToTuple<T>, UnionToIntersection<T>>[number];
+export type MergeUnionObject<T extends object> = Simplify<Merge<UnionToIntersection<T>, Partial<Pick<UnionToIntersection<T>, ExtractOptionalKey<T>>>>>;
+export {};

package/dist/util.d.ts

@@ -1,11 +1,11 @@
-import type { WritableDeep } from 'type-fest';
-import type { DictItemRecord, DictMap, Recordable } from './type';
+import type { DictItemRecord, DictMap } from './types';
 export declare function clearObj(obj: Recordable): void;
 export declare function mapToObj(map: DictMap, obj?: Recordable<DictItemRecord>): Recordable<DictItemRecord>;
 export declare function objToMap(obj: Recordable<DictItemRecord>): DictMap;
 export declare function mapToList(map: DictMap, list?: DictItemRecord[]): DictItemRecord[];
 export declare function listToMap(list: DictItemRecord[]): DictMap;
-export declare function toMap(data: Recordable<DictItemRecord> | DictItemRecord[]): DictMap;
-export declare const defineDictData: <const T extends {
-    label: string;
-} & Recordable, const K extends string>(data: Record<K, T>) => Record<K, WritableDeep<T>>;
+export declare function toMap(data: Recordable<DictItemRecord> | DictItemRecord[], { pickValues, omitValues }?: {
+    pickValues?: string[];
+    omitValues?: string[];
+}): DictMap;
+export declare const defineDictData: <T>(data: T) => T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v-dict",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "type": "module",
   "description": "Vue3 Dict Manager",
   "repository": {
@@ -32,7 +32,6 @@
   "dependencies": {
     "lodash-es": "^4.17.21",
     "type-fest": "^4.9.0",
-    "ts-toolbelt": "^9.6.0",
     "@types/lodash-es": "^4.17.12"
   },
   "peerDependencies": {
@@ -42,7 +41,7 @@
     "@changesets/cli": "^2.27.1",
     "@types/node": "^20.11.0",
     "tsup": "^8.0.1",
-    "typescript": "^5.3.3",
+    "typescript": "^5.4.0",
     "vue": "^3.4.10"
   },
   "scripts": {

package/dist/type.d.ts

@@ -1,52 +0,0 @@
-import type { O } from 'ts-toolbelt';
-import type { Simplify, ValueOf } from 'type-fest';
-import type { createPromise } from './create-promise';
-export type Recordable<T = any> = Record<string, T>;
-export type Getter<T> = () => T;
-export type MaybeGetter<T> = T | Getter<T>;
-export type UnwrapArray<T> = T extends (infer TItem)[] ? TItem : T;
-export type StringUnion<T> = T | (string & {});
-export type DictItem = {
-    label: string;
-    value: string;
-};
-export type DictItemRecord = {
-    label: string;
-    value: string;
-} & Recordable;
-export type DictMap = Map<string, DictItemRecord>;
-export type Fetch = (code: string, options?: any) => Promise<DictItemRecord[]>;
-export interface CreateDictManager<E extends ExtraGetter> {
-    fetch?: Fetch;
-    extra?: E;
-}
-export type ExtraGetter<D extends Dict<string> = Dict<string>> = (dict: D) => Recordable;
-export type UseDictOptions = {
-    clone?: boolean;
-    immediate?: boolean;
-    refresh?: boolean;
-} & Recordable;
-type ExtractFetchOptions<F extends Fetch> = Parameters<F>[1] extends infer T ? T extends undefined ? {} : T : never;
-export interface DefineDict<Extra extends ExtraGetter> {
-    <R extends boolean, F extends Fetch, D extends Recordable<Recordable>, E extends ExtraGetter>(code: string, options?: MaybeGetter<{
-        remote?: R;
-        fetch?: F;
-        data?: D;
-        extra?: E;
-    }>): (options?: Simplify<UseDictOptions & ExtractFetchOptions<F>>) => Simplify<CreateDict<D, F> & ReturnType<Extra> & ReturnType<E>>;
-}
-type CreateDict<D extends Recordable<Recordable>, F extends Fetch> = Dict<keyof D, O.Merge<UnwrapArray<Awaited<ReturnType<F>>>, ValueOf<D>>, UseDictOptions & ExtractFetchOptions<F>>;
-export type LoadPromise = ReturnType<typeof createPromise<void>>;
-export type Dict<Key extends PropertyKey = PropertyKey, ExtraItem extends Recordable = Recordable, Options = Recordable> = {
-    list: Simplify<DictItem & ExtraItem>[];
-    E: {
-        [K in Key]: K;
-    };
-    map: {
-        [K in Key]: Simplify<DictItem & ExtraItem>;
-    } & Recordable<Simplify<DictItem & ExtraItem>>;
-    loadPromise: LoadPromise;
-    load: (options?: Options) => LoadPromise;
-    clear: () => void;
-};
-export {};