@duxweb/dvha-core 1.1.30 → 1.1.31

package/dist/esm/provider/app.js

@@ -1,152 +1,125 @@
-import { defineComponent as A, inject as S, createVNode as $ } from "vue";
-import { OverlaysProvider as k } from "@overlastic/vue";
-import { useRouter as M } from "vue-router";
-import { useCan as w } from "../hooks/auth.js";
-import { useConfig as z } from "../hooks/config.js";
-import "@tanstack/vue-query";
-import "lodash-es";
-import { useManage as D } from "../hooks/manage.js";
-import "json-2-csv";
-import "@vee-validate/rules";
-import "vee-validate";
-import { useAuthStore as C } from "../stores/auth.js";
-import { useI18nStore as E } from "../stores/i18n.js";
-import "pinia";
-import { useManageStore as I } from "../stores/manage.js";
-import { useRouteStore as N } from "../stores/route.js";
-import "@vueuse/core";
-import { initJsonSchemaComponents as x } from "../hooks/json.js";
-import "../hooks/json/index.js";
-import "../utils/bus.js";
-import "colorizr";
-import "axios";
-import "clsx";
-import { DuxError as F } from "../components/status/error.js";
-import { DuxNotAuthorized as L } from "../components/status/notAuthorized.js";
-import { DuxNotFound as _ } from "../components/status/notFound.js";
-const se = /* @__PURE__ */ A({
-  name: "DuxAppProvider",
-  props: {},
-  setup(y, {
-    slots: P
-  }) {
-    const f = S("dux.manage"), p = z(), c = M();
-    return c.beforeEach(async (a, j, i) => {
-      const e = a.meta.manageName, v = a.meta.authorization === !1;
-      if (!e) {
-        const t = p.defaultManage || p.manages?.[0]?.name || "";
-        return i({
-          path: `/${t}`,
-          replace: !0
-        });
-      }
-      f && (f.value = e);
-      const h = I(e);
-      h.isInit() || h.setConfig(p.manages?.find((t) => t.name === e), p);
-      const m = N(e), o = D(e), s = C(e), d = E(e);
-      if (o.config?.i18nProvider && !d.isInit()) {
-        const t = d.getLocale();
-        t && o.config?.i18nProvider.changeLocale(t);
-      }
-      if (x(p, e), !s.isLogin())
-        return v ? i() : i({
-          path: o.getRoutePath("login"),
-          replace: !0
-        });
-      const l = (t) => t?.map((u) => ({
-        ...u,
-        path: u.path ? o.getRoutePath(u.path) : void 0
-      }));
-      if (!m.getRouteInit()) {
-        const t = o.config?.components || {}, u = [];
-        return u.push({
-          name: `${e}.notFound`,
-          label: "404",
-          path: ":pathMatch(.*)*",
-          component: t.notFound || _,
-          hidden: !0,
-          meta: {
-            can: !1
-          }
-        }), u.push({
-          name: `${e}.notAuthorized`,
-          label: "403",
-          path: "notAuthorized",
-          component: t.notAuthorized || L,
-          hidden: !0,
-          meta: {
-            can: !1
-          }
-        }), u.push({
-          name: `${e}.error`,
-          label: "500",
-          path: "error",
-          component: t.error || F,
-          hidden: !0,
-          meta: {
-            can: !1
-          }
-        }), m.setRoutes(l(o.config?.menus || [])), o.config?.apiRoutePath && await o.config?.dataProvider?.default?.custom({
-          path: o.config.apiRoutePath,
-          meta: {
-            timeout: 5e3
-          }
-        }, o, s.getUser()).then((r) => {
-          m.appendRoutes(l(r.data || []));
-        }).catch((r) => {
-          throw o.config?.authProvider?.onError?.(r).then((n) => {
-            n?.logout && (s.logout(), c.push(o.getRoutePath(n.redirectTo || "/login")));
-          }), r;
-        }), m.appendRoutes(u), m.getRoutes().forEach((r) => {
-          if (!r.path)
-            return;
-          const n = {
-            name: r.name,
-            path: r.path,
-            meta: r.meta
-          };
-          switch (r.loader) {
-            case "iframe":
-              n.component = o.config?.components?.iframe || (() => import("../components/loader/iframe.js"));
-              break;
-            case "remote":
-              n.component = o.config?.components?.remote || (() => import("../components/loader/loader.js"));
-              break;
-            case "link":
-              n.beforeEnter = () => {
-                const R = r.meta?.url || r.path;
-                return R && window.open(R, "_blank"), !1;
-              }, n.component = () => Promise.resolve({
-                template: "<div></div>"
-              });
-              break;
-            default:
-              r.component && (n.component = r.component);
-              break;
-          }
-          c.addRoute(`${e}.auth`, n);
-        }), i({
-          path: a.redirectedFrom?.path || a.path,
-          replace: !0
-        });
-      }
-      const g = ["", "/", `/${e}`, `/${e}/`];
-      if (g.includes(a.path)) {
-        const t = m.getIndexRoute();
-        return !t?.path || g.includes(t?.path) ? (console.warn("[Dux] index route not found, skip redirect"), i()) : i({
-          path: t?.path || "/",
-          replace: !0
-        });
-      }
-      const b = w(e);
-      return (a.meta?.can === void 0 || a.meta?.can === !0) && !b(a.name) ? i({
-        name: `${e}.notAuthorized`
-      }) : i();
-    }), () => $(k, null, {
-      default: () => [P.default?.()]
-    });
-  }
+import { useAuthStore as e } from "../stores/auth.js";
+import { useI18nStore as t } from "../stores/i18n.js";
+import { useManageStore as n } from "../stores/manage.js";
+import { useRouteStore as r } from "../stores/route.js";
+import "../stores/index.js";
+import { useManage as i } from "../hooks/manage.js";
+import { useCan as a } from "../hooks/auth.js";
+import { useConfig as o } from "../hooks/config.js";
+import { initJsonSchemaComponents as s } from "../hooks/json.js";
+import "../hooks/index.js";
+import { DuxError as c } from "../components/status/error.js";
+import { DuxNotAuthorized as l } from "../components/status/notAuthorized.js";
+import { DuxNotFound as u } from "../components/status/notFound.js";
+import "../components/index.js";
+import { createVNode as d, defineComponent as f, inject as p } from "vue";
+import { useRouter as m } from "vue-router";
+import { OverlaysProvider as h } from "@overlastic/vue";
+const g = /* @__PURE__ */ f({
+	name: "DuxAppProvider",
+	props: {},
+	setup(f, { slots: g }) {
+		let _ = p("dux.manage"), v = o(), y = m();
+		return y.beforeEach(async (o, d, f) => {
+			let p = o.meta.manageName, m = o.meta.authorization === !1;
+			if (!p) return f({
+				path: `/${v.defaultManage || v.manages?.[0]?.name || ""}`,
+				replace: !0
+			});
+			_ && (_.value = p);
+			let h = n(p);
+			h.isInit() || h.setConfig(v.manages?.find((e) => e.name === p), v);
+			let g = r(p), b = i(p), x = e(p), S = t(p);
+			if (b.config?.i18nProvider && !S.isInit()) {
+				let e = S.getLocale();
+				e && b.config?.i18nProvider.changeLocale(e);
+			}
+			if (s(v, p), !x.isLogin()) return m ? f() : f({
+				path: b.getRoutePath("login"),
+				replace: !0
+			});
+			let C = (e) => e?.map((e) => ({
+				...e,
+				path: e.path ? b.getRoutePath(e.path) : void 0
+			}));
+			if (!g.getRouteInit()) {
+				let e = b.config?.components || {}, t = [];
+				return t.push({
+					name: `${p}.notFound`,
+					label: "404",
+					path: ":pathMatch(.*)*",
+					component: e.notFound || u,
+					hidden: !0,
+					meta: { can: !1 }
+				}), t.push({
+					name: `${p}.notAuthorized`,
+					label: "403",
+					path: "notAuthorized",
+					component: e.notAuthorized || l,
+					hidden: !0,
+					meta: { can: !1 }
+				}), t.push({
+					name: `${p}.error`,
+					label: "500",
+					path: "error",
+					component: e.error || c,
+					hidden: !0,
+					meta: { can: !1 }
+				}), g.setRoutes(C(b.config?.menus || [])), b.config?.apiRoutePath && await b.config?.dataProvider?.default?.custom({
+					path: b.config.apiRoutePath,
+					meta: { timeout: 5e3 }
+				}, b, x.getUser()).then((e) => {
+					g.appendRoutes(C(e.data || []));
+				}).catch((e) => {
+					throw b.config?.authProvider?.onError?.(e).then((e) => {
+						e?.logout && (x.logout(), y.push(b.getRoutePath(e.redirectTo || "/login")));
+					}), e;
+				}), g.appendRoutes(t), g.getRoutes().forEach((e) => {
+					if (!e.path) return;
+					let t = {
+						name: e.name,
+						path: e.path,
+						meta: e.meta
+					};
+					switch (e.loader) {
+						case "iframe":
+							t.component = b.config?.components?.iframe || (() => import("../components/loader/iframe.js"));
+							break;
+						case "remote":
+							t.component = b.config?.components?.remote || (() => import("../components/loader/loader.js"));
+							break;
+						case "link":
+							t.beforeEnter = () => {
+								let t = e.meta?.url || e.path;
+								return t && window.open(t, "_blank"), !1;
+							}, t.component = () => Promise.resolve({ template: "<div></div>" });
+							break;
+						default:
+							e.component && (t.component = e.component);
+							break;
+					}
+					y.addRoute(`${p}.auth`, t);
+				}), f({
+					path: o.redirectedFrom?.path || o.path,
+					replace: !0
+				});
+			}
+			let w = [
+				"",
+				"/",
+				`/${p}`,
+				`/${p}/`
+			];
+			if (w.includes(o.path)) {
+				let e = g.getIndexRoute();
+				return !e?.path || w.includes(e?.path) ? (console.warn("[Dux] index route not found, skip redirect"), f()) : f({
+					path: e?.path || "/",
+					replace: !0
+				});
+			}
+			let T = a(p);
+			return (o.meta?.can === void 0 || o.meta?.can === !0) && !T(o.name) ? f({ name: `${p}.notAuthorized` }) : f();
+		}), () => d(h, null, { default: () => [g.default?.()] });
+	}
 });
-export {
-  se as DuxAppProvider
-};
+export { g as DuxAppProvider };

package/dist/esm/provider/index.js

@@ -0,0 +1,2 @@
+import "./app.js";
+import "./tab.js";

package/dist/esm/provider/tab.js

@@ -1,67 +1,50 @@
-import { defineComponent as c, watch as d, createVNode as m, Transition as l, KeepAlive as f } from "vue";
-import { useRoute as b, RouterView as h } from "vue-router";
-import "pinia";
-import "lodash-es";
-import { useRouteStore as R } from "../stores/route.js";
-import { useTabStore as w } from "../stores/tab.js";
-const k = /* @__PURE__ */ c({
-  name: "DuxTabRouterView",
-  props: {},
-  setup() {
-    const r = b(), u = w(), p = R(), n = /* @__PURE__ */ new Map(), i = (t, a) => {
-      let e;
-      const o = t;
-      return n.has(o) ? e = n.get(o) : (e = {
-        name: o,
-        render() {
-          return a;
-        }
-      }, n.set(o, e)), e;
-    };
-    u.$subscribe((t, a) => {
-      n.forEach((e) => {
-        a.tabs.some((o) => o.path === e.name) || n.delete(e.name);
-      });
-    });
-    const s = p.getIndexRoute();
-    return s && u.addTab({
-      ...s,
-      meta: {
-        ...s.meta,
-        lock: !0
-      }
-    }), d([r, () => p.routes], () => {
-      const t = p.searchRouteName(r.name);
-      if (!t)
-        return;
-      const a = {
-        label: t.label,
-        path: r.path,
-        name: t.name
-      };
-      u.addTab(a);
-    }, {
-      immediate: !0
-    }), () => m(h, null, {
-      default: ({
-        Component: t
-      }) => {
-        const a = i(r.path, t);
-        return m(l, {
-          name: "tab-fade",
-          mode: "out-in",
-          appear: !0
-        }, {
-          default: () => [m(f, {
-            include: u.tabs.map((e) => e.path || "")
-          }, [m(a, {
-            key: r.path
-          }, null)])]
-        });
-      }
-    });
-  }
+import { useRouteStore as e } from "../stores/route.js";
+import { useTabStore as t } from "../stores/tab.js";
+import "../stores/index.js";
+import { KeepAlive as n, Transition as r, createVNode as i, defineComponent as a, watch as o } from "vue";
+import { RouterView as s, useRoute as c } from "vue-router";
+const l = /* @__PURE__ */ a({
+	name: "DuxTabRouterView",
+	props: {},
+	setup() {
+		let a = c(), l = t(), u = e(), d = /* @__PURE__ */ new Map(), f = (e, t) => {
+			let n, r = e;
+			return d.has(r) ? n = d.get(r) : (n = {
+				name: r,
+				render() {
+					return t;
+				}
+			}, d.set(r, n)), n;
+		};
+		l.$subscribe((e, t) => {
+			d.forEach((e) => {
+				t.tabs.some((t) => t.path === e.name) || d.delete(e.name);
+			});
+		});
+		let p = u.getIndexRoute();
+		return p && l.addTab({
+			...p,
+			meta: {
+				...p.meta,
+				lock: !0
+			}
+		}), o([a, () => u.routes], () => {
+			let e = u.searchRouteName(a.name);
+			if (!e) return;
+			let t = {
+				label: e.label,
+				path: a.path,
+				name: e.name
+			};
+			l.addTab(t);
+		}, { immediate: !0 }), () => i(s, null, { default: ({ Component: e }) => {
+			let t = f(a.path, e);
+			return i(r, {
+				name: "tab-fade",
+				mode: "out-in",
+				appear: !0
+			}, { default: () => [i(n, { include: l.tabs.map((e) => e.path || "") }, [i(t, { key: a.path }, null)])] });
+		} });
+	}
 });
-export {
-  k as DuxTabRouterView
-};
+export { l as DuxTabRouterView };

package/dist/esm/router/index.js

@@ -0,0 +1 @@
+import "./route.js";

package/dist/esm/router/route.js

@@ -1,47 +1,40 @@
-import { createRouter as h, createWebHashHistory as u } from "vue-router";
-function s(e) {
-  const a = [
-    ...e.routes || [],
-    {
-      name: "default",
-      path: "/:catchAll(.*)",
-      redirect: `/${e.defaultManage || e.manages?.[0]?.name || ""}`
-    }
-  ];
-  return e.manages?.forEach((t) => {
-    const n = t.routes?.filter((o) => o.meta?.authorization === !0 || o.meta?.authorization === void 0) || [], r = t.routes?.filter((o) => o.meta?.authorization === !1) || [];
-    a.push({
-      name: t.name,
-      path: t.routePrefix || "",
-      children: [
-        {
-          path: "",
-          name: `${t.name}.auth`,
-          component: t.components?.authLayout,
-          children: n
-        },
-        {
-          path: "",
-          name: `${t.name}.noAuth`,
-          component: t.components?.noAuthLayout,
-          children: r
-        },
-        {
-          path: ":pathMatch(.*)*",
-          name: `${t.name}.placeholder`,
-          component: t.components?.authLayout,
-          children: []
-        }
-      ],
-      meta: {
-        manageName: t.name
-      }
-    });
-  }), h({
-    history: u(),
-    routes: a
-  });
+import { createRouter as e, createWebHashHistory as t } from "vue-router";
+function n(n) {
+	let r = [...n.routes || [], {
+		name: "default",
+		path: "/:catchAll(.*)",
+		redirect: `/${n.defaultManage || n.manages?.[0]?.name || ""}`
+	}];
+	return n.manages?.forEach((e) => {
+		let t = e.routes?.filter((e) => e.meta?.authorization === !0 || e.meta?.authorization === void 0) || [], n = e.routes?.filter((e) => e.meta?.authorization === !1) || [];
+		r.push({
+			name: e.name,
+			path: e.routePrefix || "",
+			children: [
+				{
+					path: "",
+					name: `${e.name}.auth`,
+					component: e.components?.authLayout,
+					children: t
+				},
+				{
+					path: "",
+					name: `${e.name}.noAuth`,
+					component: e.components?.noAuthLayout,
+					children: n
+				},
+				{
+					path: ":pathMatch(.*)*",
+					name: `${e.name}.placeholder`,
+					component: e.components?.authLayout,
+					children: []
+				}
+			],
+			meta: { manageName: e.name }
+		});
+	}), e({
+		history: t(),
+		routes: r
+	});
 }
-export {
-  s as initRouter
-};
+export { n as initRouter };

package/dist/esm/stores/auth.js

@@ -1,48 +1,53 @@
-import { defineStore as u } from "pinia";
-import { inject as r, ref as s } from "vue";
-function k(e) {
-  const o = r("dux.manage");
-  if (e || (e = o?.value || ""), !e)
-    throw new Error("manage not found");
-  return c(e)();
+import { inject as e, ref as t } from "vue";
+import { defineStore as n } from "pinia";
+/**
+* use auth store
+* @param manageName manage name
+* @returns auth store
+*/
+function r(t) {
+	let n = e("dux.manage");
+	if (t ||= n?.value || "", !t) throw Error("manage not found");
+	return i(t)();
 }
-function c(e) {
-  return u(`auths-${e}`, () => {
-    const o = s();
-    return {
-      data: o,
-      getUser: () => o.value || {},
-      login: (t) => {
-        o.value = {
-          token: t?.token,
-          id: t?.id,
-          info: t?.info,
-          permission: t?.permission
-        };
-      },
-      isLogin: () => !!o.value?.token,
-      logout: () => {
-        o.value = void 0;
-      },
-      update: (t) => {
-        o.value = {
-          token: t?.token,
-          id: t?.id,
-          info: t?.info,
-          permission: t?.permission
-        };
-      },
-      updateKey: (t, i) => {
-        o.value = {
-          ...o.value,
-          [t]: i
-        };
-      }
-    };
-  }, {
-    persist: !0
-  });
+/**
+* create auth store
+* @param manageName manage name
+* @returns auth store
+*/
+function i(e) {
+	return n(`auths-${e}`, () => {
+		let e = t();
+		return {
+			data: e,
+			getUser: () => e.value || {},
+			login: (t) => {
+				e.value = {
+					token: t?.token,
+					id: t?.id,
+					info: t?.info,
+					permission: t?.permission
+				};
+			},
+			isLogin: () => !!e.value?.token,
+			logout: () => {
+				e.value = void 0;
+			},
+			update: (t) => {
+				e.value = {
+					token: t?.token,
+					id: t?.id,
+					info: t?.info,
+					permission: t?.permission
+				};
+			},
+			updateKey: (t, n) => {
+				e.value = {
+					...e.value,
+					[t]: n
+				};
+			}
+		};
+	}, { persist: !0 });
 }
-export {
-  k as useAuthStore
-};
+export { r as useAuthStore };