v-dict 1.0.0

package/dist/dict-manager.d.ts

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

package/dist/index.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+var vue = require('vue');
+var lodashEs = require('lodash-es');
+
+// src/dict-manager.ts
+var clearObj = (obj) => {
+  for (const key of Object.keys(obj)) {
+    delete obj[key];
+  }
+};
+function mapToObj(map, obj = {}) {
+  clearObj(obj);
+  map.forEach((value, key) => {
+    obj[key] = value;
+  });
+  return 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;
+    }
+    map.set(key, value);
+  }
+  return map;
+}
+function mapToList(map, list = []) {
+  list.length = 0;
+  list.push(...map.values());
+  return list;
+}
+function listToMap(list) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of list) {
+    map.set(item.value, item);
+  }
+  return map;
+}
+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 : {};
+  const maps = vue.reactive({});
+  const defineDict = (code, options2) => {
+    var _a;
+    const {
+      data,
+      remote = false,
+      fetch = managerFetch,
+      extra
+    } = (_a = lodashEs.isFunction(options2) ? options2() : options2) != null ? _a : {};
+    const managerLoadPromise = vue.shallowRef(null);
+    maps[code] = /* @__PURE__ */ new Map();
+    async function loadDict(ctx, mapRef) {
+      const dataMap = toMap(lodashEs.cloneDeep(data != null ? data : {}));
+      if (remote) {
+        await (fetch == null ? void 0 : fetch(code, ctx).then((res) => {
+          mapRef.value = toMap(res != null ? res : []);
+          dataMap.forEach((value, key) => {
+            if (mapRef.value.has(key)) {
+              lodashEs.merge(mapRef.value.get(key), value);
+            }
+          });
+        }));
+      } else {
+        mapRef.value = dataMap;
+      }
+    }
+    return (useDictOptions) => {
+      useDictOptions = lodashEs.merge({ clone: false, immediate: false }, useDictOptions);
+      const { clone, immediate } = useDictOptions;
+      const loadPromise = !clone ? managerLoadPromise : vue.shallowRef(null);
+      const mapRef = !clone ? vue.toRef(maps, code) : vue.ref(/* @__PURE__ */ new Map());
+      const objRef = vue.ref({});
+      const listRef = vue.ref([]);
+      vue.watch(
+        mapRef,
+        (newValue) => {
+          mapToObj(newValue, objRef.value);
+          mapToList(newValue, listRef.value);
+        },
+        { deep: true, immediate: true }
+      );
+      const E = vue.computed(
+        () => [...mapRef.value.keys()].reduce((ret, key) => {
+          ret[key] = key;
+          return ret;
+        }, {})
+      );
+      if (remote) {
+        immediate && load();
+      } else {
+        load();
+      }
+      function load(ctx2) {
+        loadPromise.value = createPromise();
+        loadDict(lodashEs.merge({}, useDictOptions, ctx2), mapRef).then(() => {
+          var _a2;
+          (_a2 = loadPromise.value) == null ? void 0 : _a2.resolve();
+        });
+        return loadPromise.value;
+      }
+      const ctx = {
+        map: objRef,
+        list: listRef,
+        E,
+        loadPromise
+      };
+      return vue.reactive({
+        ...ctx,
+        load,
+        ...managerExtra == null ? void 0 : managerExtra(vue.reactive(ctx)),
+        ...extra == null ? void 0 : extra(vue.reactive(ctx))
+      });
+    };
+  };
+  return { defineDict };
+}
+
+exports.createDictManager = createDictManager;
+exports.defineDictData = defineDictData;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,138 @@
+import { reactive, shallowRef, toRef, ref, watch, computed } from 'vue';
+import { isFunction, merge, cloneDeep, isArray, isUndefined } from 'lodash-es';
+
+// src/dict-manager.ts
+var clearObj = (obj) => {
+  for (const key of Object.keys(obj)) {
+    delete obj[key];
+  }
+};
+function mapToObj(map, obj = {}) {
+  clearObj(obj);
+  map.forEach((value, key) => {
+    obj[key] = value;
+  });
+  return obj;
+}
+function objToMap(obj) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(obj)) {
+    if (isUndefined(value.value)) {
+      value.value = key;
+    }
+    map.set(key, value);
+  }
+  return map;
+}
+function mapToList(map, list = []) {
+  list.length = 0;
+  list.push(...map.values());
+  return list;
+}
+function listToMap(list) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of list) {
+    map.set(item.value, item);
+  }
+  return map;
+}
+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 : {};
+  const maps = reactive({});
+  const defineDict = (code, options2) => {
+    var _a;
+    const {
+      data,
+      remote = false,
+      fetch = managerFetch,
+      extra
+    } = (_a = isFunction(options2) ? options2() : options2) != null ? _a : {};
+    const managerLoadPromise = shallowRef(null);
+    maps[code] = /* @__PURE__ */ new Map();
+    async function loadDict(ctx, mapRef) {
+      const dataMap = toMap(cloneDeep(data != null ? data : {}));
+      if (remote) {
+        await (fetch == null ? void 0 : fetch(code, ctx).then((res) => {
+          mapRef.value = toMap(res != null ? res : []);
+          dataMap.forEach((value, key) => {
+            if (mapRef.value.has(key)) {
+              merge(mapRef.value.get(key), value);
+            }
+          });
+        }));
+      } else {
+        mapRef.value = dataMap;
+      }
+    }
+    return (useDictOptions) => {
+      useDictOptions = merge({ clone: false, immediate: false }, useDictOptions);
+      const { clone, immediate } = useDictOptions;
+      const loadPromise = !clone ? managerLoadPromise : shallowRef(null);
+      const mapRef = !clone ? toRef(maps, code) : ref(/* @__PURE__ */ new Map());
+      const objRef = ref({});
+      const listRef = ref([]);
+      watch(
+        mapRef,
+        (newValue) => {
+          mapToObj(newValue, objRef.value);
+          mapToList(newValue, listRef.value);
+        },
+        { deep: true, immediate: true }
+      );
+      const E = computed(
+        () => [...mapRef.value.keys()].reduce((ret, key) => {
+          ret[key] = key;
+          return ret;
+        }, {})
+      );
+      if (remote) {
+        immediate && load();
+      } else {
+        load();
+      }
+      function load(ctx2) {
+        loadPromise.value = createPromise();
+        loadDict(merge({}, useDictOptions, ctx2), mapRef).then(() => {
+          var _a2;
+          (_a2 = loadPromise.value) == null ? void 0 : _a2.resolve();
+        });
+        return loadPromise.value;
+      }
+      const ctx = {
+        map: objRef,
+        list: listRef,
+        E,
+        loadPromise
+      };
+      return reactive({
+        ...ctx,
+        load,
+        ...managerExtra == null ? void 0 : managerExtra(reactive(ctx)),
+        ...extra == null ? void 0 : extra(reactive(ctx))
+      });
+    };
+  };
+  return { defineDict };
+}
+
+export { createDictManager, defineDictData };

package/dist/type.d.ts

@@ -0,0 +1,47 @@
+import type { O } from 'ts-toolbelt';
+import type { Except, Simplify, ValueOf } from 'type-fest';
+import type { createPromise } from './util';
+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 = Simplify<DictItem & Recordable>;
+export type DictMap = Map<string, DictItemRecord>;
+export type Fetch = (code: string, ctx: 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 UseDictOptions = {
+    clone?: boolean;
+    immediate?: boolean;
+} & Recordable;
+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>;
+}
+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> = {
+    list: Simplify<DictItem & ExtraItem>[];
+    E: {
+        [K in Key]: K;
+    };
+    map: {
+        [K in Key]: Simplify<DictItem & ExtraItem>;
+    } & Recordable<Simplify<DictItem & ExtraItem>>;
+    loadPromise: Promise<void>;
+    load: (ctx: Ctx) => Promise<void>;
+};
+export type LoadPromise = ReturnType<typeof createPromise<void>> | undefined;
+export {};

package/dist/util.d.ts

@@ -0,0 +1,23 @@
+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 objToMap(obj: Recordable<DictItemRecord>): DictMap;
+export declare function mapToList(map: DictMap, list?: DictItemRecord[]): {
+    [x: string]: any;
+    label: string;
+    value: string;
+}[];
+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

@@ -0,0 +1,48 @@
+{
+  "name": "v-dict",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "vue3 dict manager",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./lib/index.d.ts"
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "lodash-es": "^4.17.21"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.1",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^20.11.0",
+    "ts-toolbelt": "^9.6.0",
+    "tsup": "^8.0.1",
+    "type-fest": "^4.9.0",
+    "typescript": "^5.3.3",
+    "vue": "^3.4.10"
+  },
+  "scripts": {
+    "watch": "tsup --watch",
+    "build": "tsup",
+    "build:type": "tsc -p ./tsconfig.json",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
+    "changeset:release:only": "changeset publish --registry=https://registry.npmjs.com/",
+    "changeset:release": "pnpm build && pnpm changeset:release:only"
+  }
+}