v-dict 2.0.3 → 2.0.4

package/README.md

@@ -5,7 +5,12 @@
  * @Description:
 -->
 
-# Vue3 Dict Manager
+# Vue3 & React Dict Manager
+
+## 目录
+
+- [Vue](#vue)
+- [React](#react)
 
 ## Installation
 
@@ -13,7 +18,7 @@
 npm i v-dict
 ```
 
-## Examples
+## Vue
 
 ### dict.ts
 
@@ -147,3 +152,85 @@ onMounted(async () => {
 })
 </script>
 ```
+
+## React
+
+### dict.ts
+
+```ts
+import { createDictManager, defineDictData } from 'v-dict/react'
+
+export const dm = createDictManager({
+  fetch: (code) =>
+    Promise.resolve([
+      { label: 'xx', value: 'xx' },
+      { label: 'xx', value: 'xx' }
+    ]),
+  extra: ({ map }) => {
+    return {
+      getLabel: (value: string) => map[value]?.label
+    }
+  }
+})
+
+export const useStatusDict = dm.defineDict('STATUS', {
+  data: defineDictData({
+    ENABLED: {
+      label: 'Enabled',
+      color: 'green'
+    },
+    DISABLED: {
+      label: 'Disabled',
+      color: 'red'
+    }
+  })
+})
+
+export const useRemoteStatusDict = dm.defineDict('REMOTE_STATUS', {
+  remote: true,
+  fetch: (code) =>
+    Promise.resolve([
+      { label: 'Enabled', value: 'ENABLED', color: 'green' },
+      { label: 'Disabled', value: 'DISABLED', color: 'red' }
+    ]),
+  extra: ({ map }) => {
+    return {
+      getItemDetail: (value: string) => map[value]
+    }
+  }
+})
+
+// clear one dict
+// dm.clear('REMOTE_STATUS')
+
+// clear all dicts
+// dm.clear()
+```
+
+### xx.tsx
+
+```tsx
+import { useEffect } from 'react'
+import { useRemoteStatusDict } from './dict'
+
+export default function Demo() {
+  const statusDict = useRemoteStatusDict({
+    // same as above
+    clone: false,
+    // same as above
+    immediate: true,
+    // same as above
+    refresh: false
+  })
+
+  return (
+    <div>
+      <div>{E.ENABLED}</div>
+      <div>{map[E.ENABLED]?.label}</div>
+      <div>{statusDict.getLabel(E.ENABLED)}</div>
+      <div>{statusDict.getItem(E.DISABLED)?.color}</div>
+      <div>{list.length}</div>
+    </div>
+  )
+}
+```

package/dist/create-promise.d.ts

@@ -0,0 +1,8 @@
+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;
+    isPending: boolean;
+};
+export declare function createPromise<T = any>(executor?: (resolve: Resolve<T>, reject: Reject) => void): CreatePromiseReturn<T>;

package/dist/index.d.ts

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

package/dist/react/index.cjs

@@ -143,10 +143,11 @@ function createDictManager(createDictManagerOptions = {}) {
   const listenersMap = /* @__PURE__ */ Object.create(null);
   function emitChange(code) {
     var _a;
-    const listeners = code ? (_a = listenersMap[code]) != null ? _a : [] : Object.values(listenersMap).flat();
-    for (let listener of listeners) {
-      listener();
-    }
+    const listeners = code ? (_a = listenersMap[code]) != null ? _a : /* @__PURE__ */ new Set() : Object.values(listenersMap).reduce((acc, set) => {
+      set.forEach((listener) => acc.add(listener));
+      return acc;
+    }, /* @__PURE__ */ new Set());
+    listeners.forEach((listener) => listener());
   }
   function clear(code) {
     var _a;
@@ -197,9 +198,10 @@ function createDictManager(createDictManagerOptions = {}) {
     }
     function subscribeMap(listener) {
       var _a;
-      listenersMap[code] = [...(_a = listenersMap[code]) != null ? _a : [], listener];
+      (_a = listenersMap[code]) != null ? _a : listenersMap[code] = /* @__PURE__ */ new Set();
+      listenersMap[code].add(listener);
       return () => {
-        listenersMap[code] = listenersMap[code].filter((l) => l !== listener);
+        listenersMap[code].delete(listener);
       };
     }
     function getMapSnapshot() {
@@ -239,11 +241,12 @@ function createDictManager(createDictManagerOptions = {}) {
       const loadPromiseRef = react.useRef(
         !clone ? globalLoadPromise : createPromise()
       );
-      const map = react.useSyncExternalStore(subscribeMap, getMapSnapshot);
+      const globalMap = react.useSyncExternalStore(subscribeMap, getMapSnapshot);
       const [clonedMap, setClonedMap] = react.useState(/* @__PURE__ */ new Map());
+      const map = !clone ? globalMap : clonedMap;
       const state = react.useMemo(
-        () => createStateFromMap(!clone ? map : clonedMap),
-        [clone, map, clonedMap]
+        () => createStateFromMap(map),
+        [map]
       );
       const load = react.useCallback((options) => {
         const oldLoadPromise = loadPromiseRef.current;

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

@@ -14,10 +14,11 @@ function createDictManager(createDictManagerOptions = {}) {
   const listenersMap = /* @__PURE__ */ Object.create(null);
   function emitChange(code) {
     var _a;
-    const listeners = code ? (_a = listenersMap[code]) != null ? _a : [] : Object.values(listenersMap).flat();
-    for (let listener of listeners) {
-      listener();
-    }
+    const listeners = code ? (_a = listenersMap[code]) != null ? _a : /* @__PURE__ */ new Set() : Object.values(listenersMap).reduce((acc, set) => {
+      set.forEach((listener) => acc.add(listener));
+      return acc;
+    }, /* @__PURE__ */ new Set());
+    listeners.forEach((listener) => listener());
   }
   function clear(code) {
     var _a;
@@ -68,9 +69,10 @@ function createDictManager(createDictManagerOptions = {}) {
     }
     function subscribeMap(listener) {
       var _a;
-      listenersMap[code] = [...(_a = listenersMap[code]) != null ? _a : [], listener];
+      (_a = listenersMap[code]) != null ? _a : listenersMap[code] = /* @__PURE__ */ new Set();
+      listenersMap[code].add(listener);
       return () => {
-        listenersMap[code] = listenersMap[code].filter((l) => l !== listener);
+        listenersMap[code].delete(listener);
       };
     }
     function getMapSnapshot() {
@@ -110,11 +112,12 @@ function createDictManager(createDictManagerOptions = {}) {
       const loadPromiseRef = useRef(
         !clone ? globalLoadPromise : createPromise()
       );
-      const map = useSyncExternalStore(subscribeMap, getMapSnapshot);
+      const globalMap = useSyncExternalStore(subscribeMap, getMapSnapshot);
       const [clonedMap, setClonedMap] = useState(/* @__PURE__ */ new Map());
+      const map = !clone ? globalMap : clonedMap;
       const state = useMemo(
-        () => createStateFromMap(!clone ? map : clonedMap),
-        [clone, map, clonedMap]
+        () => createStateFromMap(map),
+        [map]
       );
       const load = useCallback((options) => {
         const oldLoadPromise = loadPromiseRef.current;

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

@@ -0,0 +1,69 @@
+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: DictValue;
+};
+export type DictItemRecord = DictItem & Recordable;
+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[];
+    E: {
+        [X in K]: X;
+    };
+    map: {
+        [X in K]: I;
+    };
+    loadPromise: LoadPromise;
+    load: (options?: O) => LoadPromise;
+    clear: () => void;
+    getItem: (value?: I['value'] | Nil) => I | Nil;
+};
+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;
+    immediate?: boolean;
+    refresh?: boolean;
+} & Recordable;
+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?: {
+        pickValues?: Simplify<keyof D>[];
+        omitValues?: Simplify<keyof D>[];
+    }) => UseDict<E, D, F>;
+};
+type Data<R extends boolean> = Recordable<(R extends true ? {
+    label?: string;
+} : {
+    label: string;
+}) & Recordable>;
+export interface DefineDict<ME extends ExtraGetter, MF extends Fetch> {
+    <R extends boolean, F extends Fetch, D extends Data<R>, E extends ExtraGetter>(code: string, options?: MaybeGetter<{
+        remote?: R;
+        fetch?: F;
+        data?: D;
+        extra?: E;
+        transformer?: (value: DictValue) => DictValue;
+        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>;
+} ? R : never;
+export type VDictUnionValue<T extends AnyFn> = ReturnType<T> extends {
+    E: infer R;
+} ? keyof R : never;
+export {};

package/dist/types/index.d.ts

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

package/dist/types/merge.d.ts

@@ -0,0 +1,37 @@
+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 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<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 UnionRequiredKeys<T>]: Widen<UnionValueOf<T, K>>;
+} extends infer O ? {
+    [P in keyof O]: O[P];
+} : never;
+export type MergeValues<T> = MergeUnion<{
+    [K in keyof T]: T[K];
+}[keyof T]>;
+export {};

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

@@ -0,0 +1,24 @@
+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, 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[], { 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]>;
+export declare function cloneDeep<T>(value: T): T;
+export {};

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/vue/vue-dict-manager.d.ts

@@ -0,0 +1,12 @@
+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/package.json

@@ -1,14 +1,14 @@
 {
   "name": "v-dict",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "type": "module",
   "description": "Vue3 & React Dict Manager",
   "repository": {
     "type": "git",
     "url": "https://github.com/rrryyi/v-dict"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "exports": {
     ".": {
@@ -39,11 +39,9 @@
     "vue",
     "react",
     "dict",
-    "dictionary",
-    "vue3",
-    "react-dict"
+    "dictionary"
   ],
-  "author": "",
+  "author": "rrryyi",
   "license": "MIT",
   "dependencies": {},
   "peerDependencies": {