v-dict 2.0.2 → 2.0.3

package/dist/react/index.cjs

@@ -266,11 +266,11 @@ function createDictManager(createDictManagerOptions = {}) {
           emitChange(code);
           return;
         }
-        setClonedMap(map);
+        setClonedMap(/* @__PURE__ */ new Map());
       }, []);
       const getItem = react.useCallback((value) => {
         return value !== null && value !== void 0 ? state.map[value] : null;
-      }, []);
+      }, [state]);
       react.useEffect(() => {
         if (!remote || immediate) {
           if (clone) {

package/dist/react/index.js

@@ -137,11 +137,11 @@ function createDictManager(createDictManagerOptions = {}) {
           emitChange(code);
           return;
         }
-        setClonedMap(map);
+        setClonedMap(/* @__PURE__ */ new Map());
       }, []);
       const getItem = useCallback((value) => {
         return value !== null && value !== void 0 ? state.map[value] : null;
-      }, []);
+      }, [state]);
       useEffect(() => {
         if (!remote || immediate) {
           if (clone) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "v-dict",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "type": "module",
   "description": "Vue3 & React Dict Manager",
   "repository": {
     "type": "git",
-    "url": "https://github.com/xuuui/v-dict"
+    "url": "https://github.com/rrryyi/v-dict"
   },
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -57,7 +57,6 @@
     "@types/react": "^18.3.12",
     "@types/react-dom": "^18.3.1",
     "tsup": "^8.0.1",
-    "typescript": "^5.7.3",
-    "vue": "^3.4.10"
+    "typescript": "^5.7.3"
   }
 }

package/dist/create-promise.d.ts

@@ -1,8 +0,0 @@
-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

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

package/dist/react/index.d.ts

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

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

package/dist/types/merge.d.ts

@@ -1,37 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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,24 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-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;
-        }>;
-    };
-};