v-dict 1.2.6 → 1.2.7

package/README.md

@@ -1,149 +1,149 @@
-<!--
- * @Date: 2024-01-12 02:58:43
- * @Author: fangruiyi
- * @LastEditors: fangruiyi
- * @Description:
--->
-
-# Vue3 Dict Manager
-
-## Installation
-
-```sh
-npm i v-dict
-```
-
-## Examples
-
-### dict.ts
-
-```ts
-import { createDictManager, defineDictData } from 'v-dict'
-
-export const dm = createDictManager({
-  // method to fetch remote dict
-  fetch: (code) =>
-    Promise.resolve([
-      { label: 'xx', value: 'xx' },
-      { label: 'xx', value: 'xx' }
-    ]),
-  // extra attr
-  extra: ({ loadPromise, load, list, map, E }) => {
-    return {
-      getLabel: (value: string) => map[value]?.label
-    }
-  }
-})
-
-// same api for local dict or remote dict
-// local
-export const useStatusDict = dm.defineDict('STATUS', {
-  data: defineDictData({
-    ENABLED: {
-      label: 'Enabled',
-      // extra attr
-      color: 'green'
-    },
-    DISABLED: {
-      label: 'Disabled',
-      color: 'red'
-    }
-  })
-})
-// remote
-export const useRemoteStatusDict = dm.defineDict('REMOTE_STATUS', {
-  remote: true,
-  // overwrite dm fetch
-  fetch: (code) =>
-   // code = 'REMOTE_STATUS'
-    Promise.resolve([
-      { label: 'Enabled', value: 'ENABLED', color: 'green' },
-      { label: 'Disabled', value: 'DISABLED' color: 'red' }
-    ]),
-  // merge dm extra
-  extra: ({ loadPromise, load, list, map, E }) => {
-    return {
-      getItem: (value: string) => map[value]
-    }
-  }
-})
-
-// clear dict data
-// dm.clear('REMOTE_STATUS')
-
-// clear all dict data
-// dm.clear()
-```
-
-### xx.vue
-
-```vue
-<template>
-  <div>
-    {{ statusDict.E }}
-    {{ statusDict.map }}
-    {{ statusDict.list }}
-    {{ statusDict.getLabel(statusDict.E.ENABLED) }}
-    {{ statusDict.getItem(statusDict.E.DISABLED) }}
-  </div>
-</template>
-
-<script setup lang="ts">
-import { useRemoteStatusDict } from './dict'
-import { onMounted } from 'vue'
-
-const statusDict = useRemoteStatusDict({
-  // Data sharing by default, independent data source when clone is true
-  clone: true,
-  // Whether the remote dictionary loads data immediately
-  immediate: false,
-  // whether to reload
-  refresh: false
-}) // statusDict is reactive!!!
-
-const { E, map, list } = statusDict
-
-/* 
-E: {
-  ENABLED: 'ENABLED',
-  DISABLED: 'DISABLED'
-}
-
-map: {
-  ENABLED: {
-    label: 'Enabled',
-    value: 'ENABLED',
-    color: 'green'
-  },
-  DISABLED: {
-    label: 'Disabled',
-    value: 'DISABLED',
-    color: 'red'
-  }
-}
-
-list: [
-  {
-    label: 'Enabled',
-    value: 'ENABLED',
-    color: 'green'
-  },
-  {
-    label: 'Disabled',
-    value: 'DISABLED',
-    color: 'red'
-  }
-]
-*/
-
-onMounted(async () => {
-  await statusDict.load()
-
-  await statusDict.loadPromise // immediate = true, using loadPromise to wait load
-  // do after dict load
-  console.log(statusDict.list)
-  // clear dict data
-  // statusDict.clear()
-})
-</script>
-```
+<!--
+ * @Date: 2024-01-12 02:58:43
+ * @Author: fangruiyi
+ * @LastEditors: fangruiyi
+ * @Description:
+-->
+
+# Vue3 Dict Manager
+
+## Installation
+
+```sh
+npm i v-dict
+```
+
+## Examples
+
+### dict.ts
+
+```ts
+import { createDictManager, defineDictData } from 'v-dict'
+
+export const dm = createDictManager({
+  // method to fetch remote dict
+  fetch: (code) =>
+    Promise.resolve([
+      { label: 'xx', value: 'xx' },
+      { label: 'xx', value: 'xx' }
+    ]),
+  // extra attr
+  extra: ({ loadPromise, load, list, map, E }) => {
+    return {
+      getLabel: (value: string) => map[value]?.label
+    }
+  }
+})
+
+// same api for local dict or remote dict
+// local
+export const useStatusDict = dm.defineDict('STATUS', {
+  data: defineDictData({
+    ENABLED: {
+      label: 'Enabled',
+      // extra attr
+      color: 'green'
+    },
+    DISABLED: {
+      label: 'Disabled',
+      color: 'red'
+    }
+  })
+})
+// remote
+export const useRemoteStatusDict = dm.defineDict('REMOTE_STATUS', {
+  remote: true,
+  // overwrite dm fetch
+  fetch: (code) =>
+   // code = 'REMOTE_STATUS'
+    Promise.resolve([
+      { label: 'Enabled', value: 'ENABLED', color: 'green' },
+      { label: 'Disabled', value: 'DISABLED' color: 'red' }
+    ]),
+  // merge dm extra
+  extra: ({ loadPromise, load, list, map, E }) => {
+    return {
+      getItem: (value: string) => map[value]
+    }
+  }
+})
+
+// clear dict data
+// dm.clear('REMOTE_STATUS')
+
+// clear all dict data
+// dm.clear()
+```
+
+### xx.vue
+
+```vue
+<template>
+  <div>
+    {{ statusDict.E }}
+    {{ statusDict.map }}
+    {{ statusDict.list }}
+    {{ statusDict.getLabel(statusDict.E.ENABLED) }}
+    {{ statusDict.getItem(statusDict.E.DISABLED) }}
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useRemoteStatusDict } from './dict'
+import { onMounted } from 'vue'
+
+const statusDict = useRemoteStatusDict({
+  // Data sharing by default, independent data source when clone is true
+  clone: true,
+  // Whether the remote dictionary loads data immediately
+  immediate: false,
+  // whether to reload
+  refresh: false
+}) // statusDict is reactive!!!
+
+const { E, map, list } = statusDict
+
+/* 
+E: {
+  ENABLED: 'ENABLED',
+  DISABLED: 'DISABLED'
+}
+
+map: {
+  ENABLED: {
+    label: 'Enabled',
+    value: 'ENABLED',
+    color: 'green'
+  },
+  DISABLED: {
+    label: 'Disabled',
+    value: 'DISABLED',
+    color: 'red'
+  }
+}
+
+list: [
+  {
+    label: 'Enabled',
+    value: 'ENABLED',
+    color: 'green'
+  },
+  {
+    label: 'Disabled',
+    value: 'DISABLED',
+    color: 'red'
+  }
+]
+*/
+
+onMounted(async () => {
+  await statusDict.load()
+
+  await statusDict.loadPromise // immediate = true, using loadPromise to wait load
+  // do after dict load
+  console.log(statusDict.list)
+  // clear dict data
+  // statusDict.clear()
+})
+</script>
+```

package/dist/dict-manager.d.ts

@@ -1,5 +1,12 @@
-import type { CreateDictManagerOptions, DefineDict, 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;
+    maps: {
+        readonly [x: string]: ReadonlyMap<DictValue, {
+            readonly [x: string]: any;
+            readonly label: string;
+            readonly value: DictValue;
+        }>;
+    };
 };

package/dist/index.cjs

@@ -40,9 +40,13 @@ function mapToObj(map, obj = {}) {
   }
   return obj;
 }
-function checkObjItem(item, key) {
-  if (item.value === void 0)
+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());
@@ -174,7 +178,7 @@ function createDictManager(createDictManagerOptions = {}) {
       );
       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 mapRef = !clone ? vue.toRef(maps, code) : vue.ref();
       const objRef = vue.ref(/* @__PURE__ */ Object.create(null));
       const listRef = vue.ref([]);
       if (!remote || immediate) {
@@ -205,11 +209,13 @@ function createDictManager(createDictManagerOptions = {}) {
         return loadPromise.value;
       }
       function _clear() {
-        mapRef.value.clear();
+        var _a;
+        (_a = mapRef.value) == null ? void 0 : _a.clear();
       }
       vue.watch(
         mapRef,
         (newValue) => {
+          newValue != null ? newValue : newValue = /* @__PURE__ */ new Map();
           mapToObj(newValue, objRef.value);
           mapToList(newValue, listRef.value);
         },
@@ -217,13 +223,16 @@ function createDictManager(createDictManagerOptions = {}) {
       );
       const E = vue.computed(() => {
         const result = {};
+        if (!mapRef.value)
+          return result;
         for (const key of mapRef.value.keys()) {
           result[key] = key;
         }
         return result;
       });
       function getItem(value) {
-        return value !== null && value !== void 0 ? objRef.value[value] : null;
+        var _a;
+        return value !== null && value !== void 0 ? (_a = mapRef.value) == null ? void 0 : _a.get(value) : null;
       }
       const ctx = {
         map: objRef,
@@ -249,7 +258,7 @@ function createDictManager(createDictManagerOptions = {}) {
     return useDict;
   }
   const defineDict = _defineDict.bind(null, {});
-  return { defineDict, clear };
+  return { defineDict, clear, maps: vue.readonly(maps) };
 }
 
 exports.createDictManager = createDictManager;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { reactive, shallowRef, toRef, ref, watch, computed } from 'vue';
+import { reactive, readonly, shallowRef, toRef, ref, watch, computed } from 'vue';
 
 // src/dict-manager.ts
 
@@ -38,9 +38,13 @@ function mapToObj(map, obj = {}) {
   }
   return obj;
 }
-function checkObjItem(item, key) {
-  if (item.value === void 0)
+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());
@@ -172,7 +176,7 @@ function createDictManager(createDictManagerOptions = {}) {
       );
       const { clone, immediate, refresh } = useDictOptions;
       const loadPromise = !clone ? globalLoadPromise : shallowRef(createPromise());
-      const mapRef = !clone ? toRef(maps, code) : ref(/* @__PURE__ */ new Map());
+      const mapRef = !clone ? toRef(maps, code) : ref();
       const objRef = ref(/* @__PURE__ */ Object.create(null));
       const listRef = ref([]);
       if (!remote || immediate) {
@@ -203,11 +207,13 @@ function createDictManager(createDictManagerOptions = {}) {
         return loadPromise.value;
       }
       function _clear() {
-        mapRef.value.clear();
+        var _a;
+        (_a = mapRef.value) == null ? void 0 : _a.clear();
       }
       watch(
         mapRef,
         (newValue) => {
+          newValue != null ? newValue : newValue = /* @__PURE__ */ new Map();
           mapToObj(newValue, objRef.value);
           mapToList(newValue, listRef.value);
         },
@@ -215,13 +221,16 @@ function createDictManager(createDictManagerOptions = {}) {
       );
       const E = computed(() => {
         const result = {};
+        if (!mapRef.value)
+          return result;
         for (const key of mapRef.value.keys()) {
           result[key] = key;
         }
         return result;
       });
       function getItem(value) {
-        return value !== null && value !== void 0 ? objRef.value[value] : null;
+        var _a;
+        return value !== null && value !== void 0 ? (_a = mapRef.value) == null ? void 0 : _a.get(value) : null;
       }
       const ctx = {
         map: objRef,
@@ -247,7 +256,7 @@ function createDictManager(createDictManagerOptions = {}) {
     return useDict;
   }
   const defineDict = _defineDict.bind(null, {});
-  return { defineDict, clear };
+  return { defineDict, clear, maps: readonly(maps) };
 }
 
 export { createDictManager, defineDictData };

package/dist/types/dict.d.ts

@@ -1,11 +1,13 @@
 import type { createPromise } from '../create-promise';
 import type { Merge, MergeValues } from './merge';
+import type { AnyFn, MaybeGetter, MaybePromise, Nil, OptionalRequired, Recordable, Simplify } from './tool';
+export type DictValue = number | string;
 export type DictItem = {
     label: string;
-    value: string;
+    value: DictValue;
 };
 export type DictItemRecord = DictItem & Recordable;
-export type DictMap = Map<string, DictItemRecord>;
+export type DictMap = Map<DictValue, DictItemRecord>;
 export type LoadPromise = ReturnType<typeof createPromise<void>>;
 export type Dict<K extends PropertyKey = PropertyKey, I extends Recordable = DictItem, O extends Recordable = Recordable> = {
     list: I[];
@@ -22,7 +24,6 @@ export type Dict<K extends PropertyKey = PropertyKey, I extends Recordable = Dic
 };
 export type Fetch = (code: string, options?: Recordable) => MaybePromise<DictItemRecord[]>;
 type FetchOptions<F extends Fetch> = Parameters<F>[1] extends infer T ? T extends Nil ? {} : T : {};
-type FetchReturnItem<F extends Fetch> = UnwrapArray<Awaited<ReturnType<F>>> extends infer Item ? If<never, Item, {}> : {};
 export type ExtraGetter<D extends Dict<string> = Dict<string>> = (dict: D) => Recordable;
 export interface CreateDictManagerOptions<E extends ExtraGetter, F extends Fetch> {
     fetch?: F;
@@ -33,10 +34,8 @@ export type UseDictOptions = {
     immediate?: boolean;
     refresh?: boolean;
 } & Recordable;
-type Options<F extends Fetch> = FetchOptions<F> & {
-    dictOptions?: UseDictOptions;
-};
-type CreateDict<D extends Recordable<Recordable>, F extends Fetch> = Dict<keyof D, Simplify<Merge<[DictItem, FetchReturnItem<F>, MergeValues<D>]> extends infer Item ? Item extends never ? DictItem : Item extends Recordable ? OptionalRequired<Item, 'label' | 'value'> : DictItem : DictItem>, Simplify<Options<F>>>;
+type Options<F extends Fetch> = FetchOptions<F> & UseDictOptions;
+type CreateDict<D extends Recordable<Recordable>, F extends Fetch> = Dict<keyof D, Simplify<Merge<[DictItem, MergeValues<D>]> extends infer Item ? Item extends never ? DictItem : Item extends Recordable ? OptionalRequired<Item, 'label' | 'value'> : DictItem : DictItem>, Simplify<Options<F>>>;
 type _UseDict<E extends Recordable, D extends Recordable<Recordable>, F extends Fetch> = (options?: Simplify<Options<F>>) => CreateDict<D, F> & E;
 export type UseDict<E extends Recordable, D extends Recordable<Recordable>, F extends Fetch> = _UseDict<E, D, F> & {
     extend: (extendCode: string, extendOptions?: {

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 export * from './dict';
 export * from './merge';
+export * from './tool';

package/dist/types/merge.d.ts

@@ -1,20 +1,36 @@
-type UnionKeys<T> = T extends any ? keyof T : never;
-type AllKeys<T extends any[]> = UnionKeys<T[number]>;
-type GetUnionType<T extends any[], K extends PropertyKey> = T extends [infer First, ...infer Rest] ? (K extends keyof First ? First[K] : never) | GetUnionType<Rest, K> : never;
+type TupleUnionKeys<T> = T extends any ? keyof T : never;
+type TupleAllKeys<T extends any[]> = TupleUnionKeys<T[number]>;
+type TupleGetUnionType<T extends any[], K extends PropertyKey> = T extends [
+    infer First,
+    ...infer Rest
+] ? (K extends keyof First ? First[K] : undefined) | TupleGetUnionType<Rest, K> : never;
 type Widen<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
 type IsRequiredProperty<T, K extends keyof T> = {} extends Pick<T, K> ? false : true;
 type IsAllRequired<T extends any[], K> = T extends [infer First, ...infer Rest] ? (K extends keyof First ? IsRequiredProperty<First, K> : false) extends true ? IsAllRequired<Rest, K> : false : true;
-type RequiredKeys<T extends any[]> = {
-    [K in AllKeys<T>]: IsAllRequired<T, K> extends true ? K : never;
-}[AllKeys<T>];
+type TupleRequiredKeys<T extends any[]> = {
+    [K in TupleAllKeys<T>]: IsAllRequired<T, K> extends true ? K : never;
+}[TupleAllKeys<T>];
 export type Merge<T extends any[]> = {
-    [K in Exclude<AllKeys<T>, RequiredKeys<T>>]?: Widen<GetUnionType<T, K>>;
+    [K in Exclude<TupleAllKeys<T>, TupleRequiredKeys<T>>]?: Widen<TupleGetUnionType<T, K>>;
+} & {
+    [K in TupleRequiredKeys<T>]: Widen<TupleGetUnionType<T, K>>;
+} extends infer O ? {
+    [P in keyof O]: O[P];
+} : never;
+type UnionKeys<T> = T extends any ? keyof T : never;
+type UnionValueOf<T, K extends PropertyKey> = T extends any ? K extends keyof T ? T[K] : undefined : never;
+type UnionIsAlwaysPresent<T, K extends PropertyKey> = [T] extends [infer U] ? U extends any ? K extends keyof U ? true : false : never : never;
+type UnionRequiredKeys<T> = {
+    [K in UnionKeys<T>]: UnionIsAlwaysPresent<T, K> extends true ? K : never;
+}[UnionKeys<T>];
+type UnionOptionalKeys<T> = Exclude<UnionKeys<T>, UnionRequiredKeys<T>>;
+export type MergeUnion<T> = {
+    [K in UnionOptionalKeys<T>]?: Widen<UnionValueOf<T, K>>;
 } & {
-    [K in RequiredKeys<T>]: Widen<GetUnionType<T, K>>;
+    [K in UnionRequiredKeys<T>]: Widen<UnionValueOf<T, K>>;
 } extends infer O ? {
     [P in keyof O]: O[P];
 } : never;
-export type MergeUnion<T> = Merge<[T]>;
 export type MergeValues<T> = MergeUnion<{
     [K in keyof T]: T[K];
 }[keyof T]>;

package/dist/types/tool.d.ts

@@ -0,0 +1,11 @@
+export type Recordable<T = any> = Record<string, T>;
+export type Nil = undefined | null;
+export type MaybePromise<T> = T | Promise<T>;
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+export type OptionalRequired<T, K extends keyof T> = Partial<T> & Required<Pick<T, K>>;
+export type Getter<T> = () => T;
+export type MaybeGetter<T> = T | Getter<T>;
+export type AnyFn<Return = any, Args extends unknown[] = any[]> = (...args: Args) => Return;
+export type PlainObject<T = any> = Record<PropertyKey, any>;

package/dist/util.d.ts

@@ -1,13 +1,13 @@
-import type { DictItemRecord, DictMap, Merge } from './types';
+import type { AnyFn, DictItemRecord, DictMap, DictValue, Merge, PlainObject, Recordable } from './types';
 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 objToMap(obj: Recordable<DictItemRecord>): DictMap;
 export declare function mapToList(map: DictMap, list?: DictItemRecord[]): DictItemRecord[];
-export declare function listToMap(list: DictItemRecord[]): Map<string, DictItemRecord>;
+export declare function listToMap(list: DictItemRecord[]): Map<DictValue, DictItemRecord>;
 type MapOptions = {
-    pickValues?: string[];
-    omitValues?: string[];
+    pickValues?: DictValue[];
+    omitValues?: DictValue[];
 };
 export declare function toMap(data: Recordable<DictItemRecord> | DictItemRecord[], options?: MapOptions): DictMap;
 export declare const defineDictData: <T>(data: T) => T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v-dict",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "type": "module",
   "description": "Vue3 Dict Manager",
   "repository": {