v-dict 1.0.0 → 1.0.3

package/dist/create-promise.d.ts

@@ -0,0 +1,7 @@
+export type Resolve<T> = (value: T | PromiseLike<T>) => void;
+export type Reject = (reason?: any) => void;
+export type CreatePromiseReturn<T> = Promise<T> & {
+    resolve: Resolve<T>;
+    reject: Reject;
+};
+export declare function createPromise<T = any>(executor?: (resolve: Resolve<T>, reject: Reject) => void): CreatePromiseReturn<T>;

package/dist/dict-manager.d.ts

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

package/dist/index.cjs

@@ -4,6 +4,22 @@ var vue = require('vue');
 var lodashEs = require('lodash-es');
 
 // 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;
+  return promise;
+}
 var clearObj = (obj) => {
   for (const key of Object.keys(obj)) {
     delete obj[key];
@@ -41,40 +57,26 @@ function listToMap(list) {
 function toMap(data) {
   return lodashEs.isArray(data) ? listToMap(data) : objToMap(data);
 }
-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;
-  return promise;
-}
 var defineDictData = (data) => data;
 
 // src/dict-manager.ts
-function createDictManager(options) {
-  const { fetch: managerFetch, extra: managerExtra } = options != null ? options : {};
+function createDictManager(managerOptions = {}) {
+  const { fetch: managerFetch, extra: managerExtra } = managerOptions;
   const maps = vue.reactive({});
-  const defineDict = (code, options2) => {
+  const defineDict = (code, defineDictOptions) => {
     var _a;
     const {
-      data,
+      data = {},
       remote = false,
       fetch = managerFetch,
       extra
-    } = (_a = lodashEs.isFunction(options2) ? options2() : options2) != null ? _a : {};
-    const managerLoadPromise = vue.shallowRef(null);
+    } = (_a = lodashEs.isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions) != null ? _a : {};
+    const managerLoadPromise = vue.shallowRef(createPromise());
     maps[code] = /* @__PURE__ */ new Map();
-    async function loadDict(ctx, mapRef) {
-      const dataMap = toMap(lodashEs.cloneDeep(data != null ? data : {}));
+    async function loadDict(options, mapRef) {
+      const dataMap = toMap(lodashEs.cloneDeep(data));
       if (remote) {
-        await (fetch == null ? void 0 : fetch(code, ctx).then((res) => {
+        await (fetch == null ? void 0 : fetch(code, options).then((res) => {
           mapRef.value = toMap(res != null ? res : []);
           dataMap.forEach((value, key) => {
             if (mapRef.value.has(key)) {
@@ -89,7 +91,7 @@ function createDictManager(options) {
     return (useDictOptions) => {
       useDictOptions = lodashEs.merge({ clone: false, immediate: false }, useDictOptions);
       const { clone, immediate } = useDictOptions;
-      const loadPromise = !clone ? managerLoadPromise : vue.shallowRef(null);
+      const loadPromise = !clone ? managerLoadPromise : vue.shallowRef(createPromise());
       const mapRef = !clone ? vue.toRef(maps, code) : vue.ref(/* @__PURE__ */ new Map());
       const objRef = vue.ref({});
       const listRef = vue.ref([]);
@@ -101,20 +103,21 @@ function createDictManager(options) {
         },
         { deep: true, immediate: true }
       );
-      const E = vue.computed(
-        () => [...mapRef.value.keys()].reduce((ret, key) => {
-          ret[key] = key;
-          return ret;
-        }, {})
-      );
+      const E = vue.computed(() => {
+        const result = {};
+        for (const key of mapRef.value.keys()) {
+          result[key] = key;
+        }
+        return result;
+      });
       if (remote) {
         immediate && load();
       } else {
         load();
       }
-      function load(ctx2) {
+      function load(options) {
         loadPromise.value = createPromise();
-        loadDict(lodashEs.merge({}, useDictOptions, ctx2), mapRef).then(() => {
+        loadDict(lodashEs.merge({}, useDictOptions, options), mapRef).then(() => {
           var _a2;
           (_a2 = loadPromise.value) == null ? void 0 : _a2.resolve();
         });
@@ -124,13 +127,14 @@ function createDictManager(options) {
         map: objRef,
         list: listRef,
         E,
-        loadPromise
+        loadPromise,
+        load
       };
+      const reactiveCtx = vue.reactive(ctx);
       return vue.reactive({
         ...ctx,
-        load,
-        ...managerExtra == null ? void 0 : managerExtra(vue.reactive(ctx)),
-        ...extra == null ? void 0 : extra(vue.reactive(ctx))
+        ...managerExtra == null ? void 0 : managerExtra(reactiveCtx),
+        ...extra == null ? void 0 : extra(reactiveCtx)
       });
     };
   };

package/dist/index.js

@@ -2,6 +2,22 @@ import { reactive, shallowRef, toRef, ref, watch, computed } from 'vue';
 import { isFunction, merge, cloneDeep, isArray, isUndefined } from 'lodash-es';
 
 // 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;
+  return promise;
+}
 var clearObj = (obj) => {
   for (const key of Object.keys(obj)) {
     delete obj[key];
@@ -39,40 +55,26 @@ function listToMap(list) {
 function toMap(data) {
   return isArray(data) ? listToMap(data) : objToMap(data);
 }
-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;
-  return promise;
-}
 var defineDictData = (data) => data;
 
 // src/dict-manager.ts
-function createDictManager(options) {
-  const { fetch: managerFetch, extra: managerExtra } = options != null ? options : {};
+function createDictManager(managerOptions = {}) {
+  const { fetch: managerFetch, extra: managerExtra } = managerOptions;
   const maps = reactive({});
-  const defineDict = (code, options2) => {
+  const defineDict = (code, defineDictOptions) => {
     var _a;
     const {
-      data,
+      data = {},
       remote = false,
       fetch = managerFetch,
       extra
-    } = (_a = isFunction(options2) ? options2() : options2) != null ? _a : {};
-    const managerLoadPromise = shallowRef(null);
+    } = (_a = isFunction(defineDictOptions) ? defineDictOptions() : defineDictOptions) != null ? _a : {};
+    const managerLoadPromise = shallowRef(createPromise());
     maps[code] = /* @__PURE__ */ new Map();
-    async function loadDict(ctx, mapRef) {
-      const dataMap = toMap(cloneDeep(data != null ? data : {}));
+    async function loadDict(options, mapRef) {
+      const dataMap = toMap(cloneDeep(data));
       if (remote) {
-        await (fetch == null ? void 0 : fetch(code, ctx).then((res) => {
+        await (fetch == null ? void 0 : fetch(code, options).then((res) => {
           mapRef.value = toMap(res != null ? res : []);
           dataMap.forEach((value, key) => {
             if (mapRef.value.has(key)) {
@@ -87,7 +89,7 @@ function createDictManager(options) {
     return (useDictOptions) => {
       useDictOptions = merge({ clone: false, immediate: false }, useDictOptions);
       const { clone, immediate } = useDictOptions;
-      const loadPromise = !clone ? managerLoadPromise : shallowRef(null);
+      const loadPromise = !clone ? managerLoadPromise : shallowRef(createPromise());
       const mapRef = !clone ? toRef(maps, code) : ref(/* @__PURE__ */ new Map());
       const objRef = ref({});
       const listRef = ref([]);
@@ -99,20 +101,21 @@ function createDictManager(options) {
         },
         { deep: true, immediate: true }
       );
-      const E = computed(
-        () => [...mapRef.value.keys()].reduce((ret, key) => {
-          ret[key] = key;
-          return ret;
-        }, {})
-      );
+      const E = computed(() => {
+        const result = {};
+        for (const key of mapRef.value.keys()) {
+          result[key] = key;
+        }
+        return result;
+      });
       if (remote) {
         immediate && load();
       } else {
         load();
       }
-      function load(ctx2) {
+      function load(options) {
         loadPromise.value = createPromise();
-        loadDict(merge({}, useDictOptions, ctx2), mapRef).then(() => {
+        loadDict(merge({}, useDictOptions, options), mapRef).then(() => {
           var _a2;
           (_a2 = loadPromise.value) == null ? void 0 : _a2.resolve();
         });
@@ -122,13 +125,14 @@ function createDictManager(options) {
         map: objRef,
         list: listRef,
         E,
-        loadPromise
+        loadPromise,
+        load
       };
+      const reactiveCtx = reactive(ctx);
       return reactive({
         ...ctx,
-        load,
-        ...managerExtra == null ? void 0 : managerExtra(reactive(ctx)),
-        ...extra == null ? void 0 : extra(reactive(ctx))
+        ...managerExtra == null ? void 0 : managerExtra(reactiveCtx),
+        ...extra == null ? void 0 : extra(reactiveCtx)
       });
     };
   };

package/dist/type.d.ts

@@ -1,6 +1,6 @@
 import type { O } from 'ts-toolbelt';
-import type { Except, Simplify, ValueOf } from 'type-fest';
-import type { createPromise } from './util';
+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>;
@@ -10,29 +10,33 @@ export type DictItem = {
     label: string;
     value: string;
 };
-export type DictItemRecord = Simplify<DictItem & Recordable>;
+export type DictItemRecord = {
+    label: string;
+    value: string;
+} & Recordable;
 export type DictMap = Map<string, DictItemRecord>;
-export type Fetch = (code: string, ctx: any) => Promise<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: Except<D, 'load'>) => Recordable;
+export type ExtraGetter<D extends Dict<string> = Dict<string>> = (dict: D) => Recordable;
 export type UseDictOptions = {
     clone?: boolean;
     immediate?: 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?: UseDictOptions & GetFetchCtx<F>) => CreateDict<D, F> & ReturnType<Extra> & ReturnType<E>;
+    }>): (options?: Simplify<UseDictOptions & ExtractFetchOptions<F>>) => Simplify<CreateDict<D, F> & ReturnType<Extra> & ReturnType<E>>;
 }
-type GetFetchCtx<F extends Fetch> = Parameters<F>[1] extends undefined ? {} : Parameters<F>[1];
-type CreateDict<D extends Recordable<Recordable>, F extends Fetch> = Dict<keyof D, O.Merge<UnwrapArray<Awaited<ReturnType<F>>>, ValueOf<D>>, UseDictOptions & GetFetchCtx<F>>;
-export type Dict<Key extends PropertyKey = PropertyKey, ExtraItem extends Recordable = Recordable, Ctx = any> = {
+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;
@@ -40,8 +44,7 @@ export type Dict<Key extends PropertyKey = PropertyKey, ExtraItem extends Record
     map: {
         [K in Key]: Simplify<DictItem & ExtraItem>;
     } & Recordable<Simplify<DictItem & ExtraItem>>;
-    loadPromise: Promise<void>;
-    load: (ctx: Ctx) => Promise<void>;
+    loadPromise: LoadPromise;
+    load: (options: Options) => LoadPromise;
 };
-export type LoadPromise = ReturnType<typeof createPromise<void>> | undefined;
 export {};

package/dist/util.d.ts

@@ -1,23 +1,10 @@
 import type { WritableDeep } from 'type-fest';
 import type { DictItemRecord, DictMap, Recordable } from './type';
-export declare function mapToObj(map: DictMap, obj?: Recordable<DictItemRecord>): Recordable<{
-    [x: string]: any;
-    label: string;
-    value: string;
-}>;
+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[]): {
-    [x: string]: any;
-    label: string;
-    value: string;
-}[];
+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 type CreatePromiseReturn<T> = Promise<T> & {
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-};
-export declare function createPromise<T = any>(executor?: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): CreatePromiseReturn<T>;
 export declare const defineDictData: <const T extends {
     label: string;
 } & Recordable, const K extends string>(data: Record<K, T>) => Record<K, WritableDeep<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v-dict",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "type": "module",
   "description": "vue3 dict manager",
   "main": "dist/index.js",
@@ -17,7 +17,10 @@
   "files": [
     "dist"
   ],
-  "keywords": [],
+  "keywords": [
+    "vue",
+    "dict"
+  ],
   "author": "",
   "license": "MIT",
   "dependencies": {