npm - api-dict-select - Versions diffs - 0.1.1 → 0.1.2 - Mend

api-dict-select 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.js +212 -0
package/dist/index.umd.cjs +1 -0
package/dist/types/DictSelect.vue.d.ts +92 -0
package/dist/types/cache.d.ts +7 -0
package/dist/types/index.d.ts +10 -0
package/dist/types/types.d.ts +10 -0
package/package.json +1 -1

package/dist/index.js CHANGED Viewed

@@ -0,0 +1,212 @@
+import { defineComponent as z, useModel as f, ref as h, computed as U, watch as p, openBlock as B, createBlock as D, unref as L, withCtx as G, createElementBlock as H, Fragment as P, renderList as Q, mergeModels as N } from "vue";
+import { ElSelect as W, ElOption as X } from "element-plus";
+const M = /* @__PURE__ */ new Map(), Y = () => M, Z = (n) => {
+  if (n) {
+    M.delete(n);
+    return;
+  }
+  M.clear();
+}, I = /* @__PURE__ */ z({
+  __name: "DictSelect",
+  props: /* @__PURE__ */ N({
+    placeholder: { default: "全部" },
+    disabled: { type: Boolean, default: !1 },
+    optionLabel: { default: "k" },
+    optionValue: { default: "v" },
+    optionDisabledField: { default: "text" },
+    optionDisabledValue: { type: [String, Number, Boolean], default: "disable" },
+    filter: { type: Boolean, default: !1 },
+    clearable: { type: Boolean, default: !0 },
+    vModelToNumber: { type: Boolean, default: !1 },
+    vModelToString: { type: Boolean, default: !1 },
+    isBuffer: { type: Boolean, default: !0 },
+    isLabel: { type: Boolean, default: !1 },
+    api: {},
+    mock: { default: () => [] },
+    multiple: { type: Boolean, default: !1 },
+    param: { default: () => ({}) },
+    callApiIfNeeded: { type: Boolean, default: !0 },
+    cacheKey: { default: "" },
+    transform: { type: Function, default: void 0 },
+    immediate: { type: Boolean, default: !0 },
+    autoClearInvalidValue: { type: Boolean, default: !0 }
+  }, {
+    modelValue: {},
+    modelModifiers: {},
+    options: {},
+    optionsModifiers: {},
+    response: {},
+    responseModifiers: {},
+    loading: { type: Boolean },
+    loadingModifiers: {},
+    selectedOption: {},
+    selectedOptionModifiers: {}
+  }),
+  emits: /* @__PURE__ */ N(["label", "allData", "options", "loaded", "error", "onClear"], ["update:modelValue", "update:options", "update:response", "update:loading", "update:selectedOption"]),
+  setup(n, { expose: w, emit: E }) {
+    const e = n, u = f(n, "modelValue"), O = f(n, "options"), T = f(n, "response"), K = f(n, "loading"), A = f(n, "selectedOption"), i = h([]), v = h(!1), r = h(), b = Y();
+    let m = 0;
+    const s = E, k = (l) => {
+      var a, t, o;
+      return ((a = l == null ? void 0 : l.result) == null ? void 0 : a.list) || ((t = l == null ? void 0 : l.result) == null ? void 0 : t.data) || ((o = l == null ? void 0 : l.result) == null ? void 0 : o.result) || (l == null ? void 0 : l.result) || (l == null ? void 0 : l.data) || l || [];
+    }, F = () => !e.param || Object.keys(e.param).length === 0 ? !0 : Object.values(e.param).every(
+      (l) => l != null && l !== ""
+    ), C = () => {
+      var a;
+      return `${e.cacheKey || ((a = e.api) == null ? void 0 : a.name) || "dict-select"}:${JSON.stringify(e.param || {})}`;
+    }, c = () => e.multiple ? Array.isArray(u.value) ? i.value.filter(
+      (l) => u.value.includes(l[e.optionValue])
+    ) : [] : i.value.find(
+      (l) => l[e.optionValue] === u.value
+    ), d = () => {
+      O.value = i.value, T.value = r.value, K.value = v.value, A.value = c();
+    }, j = (l) => {
+      e.vModelToNumber && l.forEach((a) => {
+        a[e.optionValue] = Number(a[e.optionValue]);
+      }), e.vModelToString && l.forEach((a) => {
+        a[e.optionValue] = String(a[e.optionValue]);
+      });
+    }, J = () => {
+      if (!e.autoClearInvalidValue)
+        return;
+      if (e.multiple) {
+        if (Array.isArray(u.value) && u.value.length > 0) {
+          const a = u.value.filter(
+            (t) => i.value.some((o) => o[e.optionValue] === t)
+          );
+          a.length !== u.value.length && (u.value = a);
+        }
+        return;
+      }
+      i.value.findIndex(
+        (a) => a[e.optionValue] === u.value
+      ) === -1 && (u.value = void 0);
+    }, R = () => {
+      s("onClear");
+    }, y = (l, a, t) => {
+      i.value = l, r.value = a, j(i.value), J(), d(), s("loaded", {
+        options: i.value,
+        response: r.value,
+        fromCache: t
+      });
+    }, g = async (l = !1) => {
+      if (e.mock.length > 0) {
+        y(e.mock, e.mock, !1);
+        return;
+      }
+      if (!e.api) {
+        i.value = [], r.value = void 0, d();
+        return;
+      }
+      if (!e.callApiIfNeeded || !F()) {
+        i.value = [], r.value = void 0, d();
+        return;
+      }
+      const a = C();
+      if (!l && e.isBuffer && b.has(a)) {
+        const o = b.get(a);
+        y((o == null ? void 0 : o.options) || [], o == null ? void 0 : o.response, !0);
+        return;
+      }
+      const t = ++m;
+      v.value = !0, d();
+      try {
+        const o = await e.api(e.param);
+        if (t !== m)
+          return;
+        const S = e.transform ? e.transform(k(o), o) : k(o), x = Array.isArray(S) ? S : [];
+        e.isBuffer && b.set(a, {
+          options: x,
+          response: o
+        }), y(x, o, !1);
+      } catch (o) {
+        if (t !== m)
+          return;
+        s("error", o), i.value = [], r.value = void 0, d();
+      } finally {
+        t === m && (v.value = !1, d());
+      }
+    }, q = async (l = !0) => {
+      await g(l);
+    }, $ = () => {
+      Z(C());
+    }, V = U(() => {
+      if (e.multiple) {
+        const a = c();
+        return Array.isArray(a) ? a.map((t) => t[e.optionLabel]) : [];
+      }
+      const l = c();
+      return !l || Array.isArray(l) ? "" : l[e.optionLabel] ?? "";
+    });
+    return p(
+      () => i.value,
+      () => {
+        s("options", i.value), O.value = i.value;
+      }
+    ), p(
+      () => e.mock,
+      () => {
+        if (e.mock.length > 0) {
+          y(e.mock, e.mock, !1);
+          return;
+        }
+        e.api || (i.value = [], r.value = void 0, d());
+      }
+    ), p(
+      () => e.api,
+      () => {
+        e.immediate && g();
+      },
+      { immediate: e.immediate }
+    ), p(
+      () => e.param,
+      (l, a) => {
+        JSON.stringify(l) !== JSON.stringify(a) && g();
+      },
+      { deep: !0 }
+    ), p(
+      () => [u.value, i.value],
+      () => {
+        const l = c();
+        A.value = l, e.isLabel && s(
+          "label",
+          Array.isArray(V.value) ? V.value.join(",") : V.value
+        ), s("allData", l);
+      },
+      { immediate: !0, deep: !0 }
+    ), w({
+      refresh: q,
+      clearCache: $,
+      getOptions: () => i.value,
+      getResponse: () => r.value,
+      getSelectedOption: c
+    }), (l, a) => (B(), D(L(W), {
+      modelValue: u.value,
+      "onUpdate:modelValue": a[0] || (a[0] = (t) => u.value = t),
+      filterable: e.filter,
+      disabled: e.disabled,
+      placeholder: e.placeholder,
+      clearable: e.clearable,
+      multiple: e.multiple,
+      loading: v.value,
+      onClear: R
+    }, {
+      default: G(() => [
+        (B(!0), H(P, null, Q(i.value, (t) => (B(), D(L(X), {
+          key: t[e.optionValue],
+          label: t[e.optionLabel],
+          value: t[e.optionValue],
+          disabled: t[e.optionDisabledField] === e.optionDisabledValue
+        }, null, 8, ["label", "value", "disabled"]))), 128))
+      ]),
+      _: 1
+    }, 8, ["modelValue", "filterable", "disabled", "placeholder", "clearable", "multiple", "loading"]));
+  }
+}), _ = I;
+_.install = (n) => {
+  n.component("DictSelect", I);
+};
+export {
+  I as DictSelect,
+  _ as default
+};

package/dist/index.umd.cjs CHANGED Viewed

@@ -0,0 +1 @@

package/dist/types/DictSelect.vue.d.ts CHANGED Viewed

@@ -0,0 +1,92 @@
+import type { ApiFunction, OptionItem, TransformFunction } from './types';
+type __VLS_Props = {
+    placeholder?: string;
+    disabled?: boolean;
+    optionLabel?: string;
+    optionValue?: string;
+    optionDisabledField?: string;
+    optionDisabledValue?: string | number | boolean;
+    filter?: boolean;
+    clearable?: boolean;
+    vModelToNumber?: boolean;
+    vModelToString?: boolean;
+    isBuffer?: boolean;
+    isLabel?: boolean;
+    api?: ApiFunction;
+    mock?: OptionItem[];
+    multiple?: boolean;
+    param?: Record<string, any>;
+    callApiIfNeeded?: boolean;
+    cacheKey?: string;
+    transform?: TransformFunction;
+    immediate?: boolean;
+    autoClearInvalidValue?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: any;
+    'options'?: OptionItem[] | undefined;
+    'response'?: any;
+    'loading'?: boolean | undefined;
+    'selectedOption'?: OptionItem | OptionItem[] | undefined;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {
+    refresh: (force?: boolean) => Promise<void>;
+    clearCache: () => void;
+    getOptions: () => OptionItem[];
+    getResponse: () => any;
+    getSelectedOption: () => OptionItem | OptionItem[] | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    options: (args_0: OptionItem[]) => any;
+    label: (args_0: string) => any;
+    allData: (args_0: OptionItem | OptionItem[] | undefined) => any;
+    loaded: (args_0: {
+        options: OptionItem[];
+        response: any;
+        fromCache: boolean;
+    }) => any;
+    error: (args_0: unknown) => any;
+    onClear: () => any;
+    "update:modelValue": (value: any) => any;
+    "update:options": (value: OptionItem[] | undefined) => any;
+    "update:response": (value: any) => any;
+    "update:loading": (value: boolean | undefined) => any;
+    "update:selectedOption": (value: OptionItem | OptionItem[] | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onOptions?: ((args_0: OptionItem[]) => any) | undefined;
+    onLabel?: ((args_0: string) => any) | undefined;
+    onAllData?: ((args_0: OptionItem | OptionItem[] | undefined) => any) | undefined;
+    onLoaded?: ((args_0: {
+        options: OptionItem[];
+        response: any;
+        fromCache: boolean;
+    }) => any) | undefined;
+    onError?: ((args_0: unknown) => any) | undefined;
+    onOnClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    "onUpdate:options"?: ((value: OptionItem[] | undefined) => any) | undefined;
+    "onUpdate:response"?: ((value: any) => any) | undefined;
+    "onUpdate:loading"?: ((value: boolean | undefined) => any) | undefined;
+    "onUpdate:selectedOption"?: ((value: OptionItem | OptionItem[] | undefined) => any) | undefined;
+}>, {
+    placeholder: string;
+    disabled: boolean;
+    optionLabel: string;
+    optionValue: string;
+    optionDisabledField: string;
+    optionDisabledValue: string | number | boolean;
+    filter: boolean;
+    clearable: boolean;
+    vModelToNumber: boolean;
+    vModelToString: boolean;
+    isBuffer: boolean;
+    isLabel: boolean;
+    mock: OptionItem[];
+    multiple: boolean;
+    param: Record<string, any>;
+    callApiIfNeeded: boolean;
+    cacheKey: string;
+    transform: TransformFunction;
+    immediate: boolean;
+    autoClearInvalidValue: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/cache.d.ts CHANGED Viewed

@@ -0,0 +1,7 @@
+export type OptionItem = Record<string, any>;
+export interface CacheEntry {
+    options: OptionItem[];
+    response: any;
+}
+export declare const getOptionCache: () => Map<string, CacheEntry>;
+export declare const clearOptionCache: (key?: string) => void;

package/dist/types/index.d.ts CHANGED Viewed

@@ -0,0 +1,10 @@
+import type { App } from 'vue';
+import DictSelect from './DictSelect.vue';
+import type { DictSelectExpose, OptionItem } from './types';
+type DictSelectPlugin = typeof DictSelect & {
+    install: (app: App) => void;
+};
+declare const plugin: DictSelectPlugin;
+export default plugin;
+export { DictSelect };
+export type { DictSelectExpose, OptionItem };

package/dist/types/types.d.ts CHANGED Viewed

@@ -0,0 +1,10 @@
+export type OptionItem = Record<string, any>;
+export type ApiFunction = (params?: Record<string, any>) => Promise<any>;
+export type TransformFunction = (raw: any, response: any) => OptionItem[];
+export interface DictSelectExpose {
+    refresh: (force?: boolean) => Promise<void>;
+    clearCache: () => void;
+    getOptions: () => OptionItem[];
+    getResponse: () => any;
+    getSelectedOption: () => OptionItem | OptionItem[] | undefined;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "api-dict-select",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A reusable select component that loads options from an API automatically.",
   "type": "module",
   "main": "dist/index.umd.cjs",