@munet/ui 1.0.0

package/dist/_virtual/_plugin-vue_export-helper.js

@@ -0,0 +1,9 @@
+const s = (t, e) => {
+  const o = t.__vccOpts || t;
+  for (const [r, c] of e)
+    o[r] = c;
+  return o;
+};
+export {
+  s as default
+};

package/dist/components/Button/LoadingBackground/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/Button/LoadingBackground/index.js

@@ -0,0 +1,14 @@
+import { defineComponent as e, createVNode as t } from "vue";
+import r from "./index.module.sass.js";
+const s = /* @__PURE__ */ e({
+  setup(a, {
+    slots: o
+  }) {
+    return () => t("div", {
+      class: r.loading
+    }, [o.default?.()]);
+  }
+});
+export {
+  s as default
+};

package/dist/components/Button/LoadingBackground/index.module.css

@@ -0,0 +1 @@
+.index-module_o5f0y{width:100%;background-image:repeating-linear-gradient(-45deg,var(--color) 25%,transparent 0,transparent 50%,var(--color) 0,var(--color) 75%,transparent 0);background-size:30px 30px;-webkit-mask-image:linear-gradient(to top,#000,#0009,#0003,#0000);mask-image:linear-gradient(to top,#000,#0009,#0003,#0000);animation:index-module_SB-Ki .8s linear infinite}@keyframes index-module_SB-Ki{0%{background-position:0 0}to{background-position:-30px 0}}

package/dist/components/Button/LoadingBackground/index.module.sass.js

@@ -0,0 +1,7 @@
+const o = "index-module_o5f0y", d = {
+  loading: o
+};
+export {
+  d as default,
+  o as loading
+};

package/dist/components/Button/index.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    onClick: PropType<() => any>;
+    onContextmenu: PropType<() => any>;
+    disabled: BooleanConstructor;
+    ing: BooleanConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    onClick: PropType<() => any>;
+    onContextmenu: PropType<() => any>;
+    disabled: BooleanConstructor;
+    ing: BooleanConstructor;
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    ing: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/Button/index.js

@@ -0,0 +1,29 @@
+import { defineComponent as o, createVNode as n } from "vue";
+import { theme as i } from "../../themes/index.js";
+import l from "./LoadingBackground/index.js";
+const m = /* @__PURE__ */ o({
+  props: {
+    onClick: Function,
+    onContextmenu: Function,
+    disabled: Boolean,
+    ing: Boolean
+  },
+  setup(e, {
+    emit: a,
+    slots: t
+  }) {
+    return () => n("button", {
+      class: "relative of-hidden",
+      disabled: e.disabled || e.ing,
+      onClick: e.onClick,
+      onContextmenu: e.onContextmenu
+    }, [n("div", {
+      class: "z-2 inline-flex items-center justify-center"
+    }, [t.default?.()]), e.ing && n(l, {
+      class: ["absolute bottom-0 left-0 right-0 top-25% z-1", i.value.loadingBackground]
+    }, null)]);
+  }
+});
+export {
+  m as default
+};

package/dist/components/CheckBox/FlagCheckBox.d.ts

@@ -0,0 +1,35 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+    flag: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onChange: PropType<() => void>;
+    gap: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+    flag: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onChange: PropType<() => void>;
+    gap: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    value: number;
+    gap: string;
+    flag: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/CheckBox/FlagCheckBox.js

@@ -0,0 +1,41 @@
+import { defineComponent as n, computed as f, createVNode as g } from "vue";
+import d from "./index.js";
+const m = /* @__PURE__ */ n({
+  props: {
+    value: {
+      type: Number,
+      default: 0
+    },
+    flag: {
+      type: Number,
+      default: 0
+    },
+    onChange: Function,
+    gap: {
+      type: String,
+      default: "0.5rem"
+    }
+  },
+  setup(e, {
+    emit: t,
+    slots: l
+  }) {
+    const u = f({
+      get: () => !!(e.value & e.flag),
+      set: (a) => {
+        a ? t("update:value", e.value | e.flag) : t("update:value", e.value & ~e.flag), e.onChange?.();
+      }
+    });
+    return () => g(d, {
+      value: u.value,
+      "onUpdate:value": (a) => u.value = a,
+      onChange: e.onChange,
+      gap: e.gap
+    }, {
+      default: () => [l.default?.()]
+    });
+  }
+});
+export {
+  m as default
+};

package/dist/components/CheckBox/index.d.ts

@@ -0,0 +1,26 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: BooleanConstructor;
+    egg: BooleanConstructor;
+    debounce: BooleanConstructor;
+    gap: {
+        type: StringConstructor;
+        default: string;
+    };
+    onChange: PropType<() => void>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: BooleanConstructor;
+    egg: BooleanConstructor;
+    debounce: BooleanConstructor;
+    gap: {
+        type: StringConstructor;
+        default: string;
+    };
+    onChange: PropType<() => void>;
+}>> & Readonly<{}>, {
+    value: boolean;
+    egg: boolean;
+    debounce: boolean;
+    gap: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/CheckBox/index.js

@@ -0,0 +1,45 @@
+import { defineComponent as r, useId as f, ref as m, createVNode as o, withDirectives as h, vModelCheckbox as v } from "vue";
+import { addToast as C } from "../../controllers/toastController.js";
+import { useVModel as b } from "@vueuse/core";
+import * as l from "lodash-es";
+const y = /* @__PURE__ */ r({
+  props: {
+    value: Boolean,
+    egg: Boolean,
+    debounce: Boolean,
+    gap: {
+      type: String,
+      default: "0.5rem"
+    },
+    onChange: Function
+  },
+  setup(e, {
+    emit: u,
+    slots: c
+  }) {
+    const a = f(), t = b(e, "value", u), n = m(0), i = l.debounce(() => n.value = 0, 500), d = l.debounce(() => e.onChange?.(), 500), s = () => {
+      e.egg && (n.value++, n.value === 16 && C({
+        message: "不要再打了……要坏了………",
+        type: "warning"
+      }), i()), e.debounce ? d() : e.onChange?.();
+    };
+    return () => o("div", {
+      class: "flex items-center",
+      style: {
+        gap: e.gap
+      }
+    }, [h(o("input", {
+      class: "shrink-0",
+      id: a,
+      type: "checkbox",
+      "onUpdate:modelValue": (g) => t.value = g,
+      title: e.egg ? "是不是想对着这里打纵连？" : "",
+      onChange: s
+    }, null), [[v, t.value]]), o("label", {
+      for: a
+    }, [c.default?.()])]);
+  }
+});
+export {
+  y as default
+};

package/dist/components/DateFormat.d.ts

@@ -0,0 +1,22 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: (DateConstructor | StringConstructor | NumberConstructor)[];
+        required: true;
+    };
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => string, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: (DateConstructor | StringConstructor | NumberConstructor)[];
+        required: true;
+    };
+    format: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    format: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DateFormat.js

@@ -0,0 +1,23 @@
+import { useDateFormat as r } from "@vueuse/core";
+import { defineComponent as a } from "vue";
+const n = /* @__PURE__ */ a({
+  props: {
+    value: {
+      type: [String, Number, Date],
+      required: !0
+    },
+    format: {
+      type: String,
+      default: "YYYY/MM/DD HH:mm:ss"
+    }
+  },
+  setup(t, {
+    emit: m
+  }) {
+    const e = r(t.value, t.format);
+    return () => e.value;
+  }
+});
+export {
+  n as default
+};

package/dist/components/DropMenu/DropDown.d.ts

@@ -0,0 +1,49 @@
+import { PropType, CSSProperties } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    innerClass: (StringConstructor | ArrayConstructor)[];
+    innerStyle: PropType<CSSProperties>;
+    buttonText: {
+        type: PropType<string>;
+        default: string;
+    };
+    buttonIng: BooleanConstructor;
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    autoPosition: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    innerClass: (StringConstructor | ArrayConstructor)[];
+    innerStyle: PropType<CSSProperties>;
+    buttonText: {
+        type: PropType<string>;
+        default: string;
+    };
+    buttonIng: BooleanConstructor;
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    autoPosition: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    gap: number;
+    buttonIng: boolean;
+    buttonText: string;
+    autoPosition: boolean;
+    maxHeight: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DropMenu/DropDown.js

@@ -0,0 +1,77 @@
+import { defineComponent as p, ref as s, computed as b, createVNode as a } from "vue";
+import { onClickOutside as v } from "@vueuse/core";
+import y from "../TransitionVertical.vue.js";
+import w from "../Button/index.js";
+const H = /* @__PURE__ */ p({
+  props: {
+    innerClass: [String, Array],
+    innerStyle: [Object, String],
+    buttonText: {
+      type: String,
+      default: "Menu"
+    },
+    buttonIng: Boolean,
+    gap: {
+      type: Number,
+      default: 8
+    },
+    autoPosition: {
+      type: Boolean,
+      default: !0
+    },
+    maxHeight: {
+      type: Number,
+      default: 200
+    }
+  },
+  setup(o, {
+    emit: x,
+    slots: l,
+    expose: f
+  }) {
+    const n = s(!1), i = s(null), r = s("bottom");
+    v(i, (t) => n.value = !1);
+    const m = () => {
+      if (!o.autoPosition || !i.value) return;
+      const t = i.value.getBoundingClientRect(), c = window.innerHeight - t.bottom, d = t.top;
+      c < o.maxHeight && d > c ? r.value = "top" : r.value = "bottom";
+    }, u = (t) => {
+      const e = typeof t == "boolean" ? t : !n.value;
+      e && m(), n.value = e;
+    };
+    f({
+      setShow: (t) => {
+        u(t);
+      }
+    });
+    const g = b(() => {
+      const t = o.innerStyle || {};
+      if (!o.autoPosition) return t;
+      const e = {
+        position: "absolute",
+        zIndex: 100
+      };
+      return r.value === "bottom" ? (e.top = `calc(100% + ${o.gap}px)`, e.transformOrigin = "top center") : (e.bottom = `calc(100% + ${o.gap}px)`, e.top = "auto", e.transformOrigin = "bottom center"), {
+        ...t,
+        ...e
+      };
+    });
+    return () => a("div", {
+      class: "relative",
+      ref: i
+    }, [l.trigger ? l.trigger(u) : a(w, {
+      ing: o.buttonIng,
+      onClick: () => u()
+    }, {
+      default: () => [o.buttonText]
+    }), a(y, null, {
+      default: () => [n.value && a("div", {
+        class: o.innerClass,
+        style: g.value
+      }, [l.default?.()])]
+    })]);
+  }
+});
+export {
+  H as default
+};

package/dist/components/DropMenu/index.d.ts

@@ -0,0 +1,54 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    buttonText: {
+        type: PropType<string>;
+        default: string;
+    };
+    width: {
+        type: PropType<string>;
+        default: string;
+    };
+    row: BooleanConstructor;
+    options: {
+        type: PropType<{
+            label: string;
+            action: () => any;
+        }[]>;
+        default: () => never[];
+    };
+    innerClass: {
+        type: PropType<string>;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    buttonText: {
+        type: PropType<string>;
+        default: string;
+    };
+    width: {
+        type: PropType<string>;
+        default: string;
+    };
+    row: BooleanConstructor;
+    options: {
+        type: PropType<{
+            label: string;
+            action: () => any;
+        }[]>;
+        default: () => never[];
+    };
+    innerClass: {
+        type: PropType<string>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    width: string;
+    innerClass: string;
+    options: {
+        label: string;
+        action: () => any;
+    }[];
+    buttonText: string;
+    row: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DropMenu/index.js

@@ -0,0 +1,48 @@
+import { defineComponent as a, ref as i, createVNode as r } from "vue";
+import u from "./DropDown.js";
+const s = /* @__PURE__ */ a({
+  props: {
+    buttonText: {
+      type: String,
+      default: "Menu"
+    },
+    width: {
+      type: String,
+      default: "max-context"
+    },
+    row: Boolean,
+    options: {
+      type: Array,
+      default: () => []
+    },
+    innerClass: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(t, {
+    slots: o
+  }) {
+    const e = i();
+    return () => r(u, {
+      buttonText: t.buttonText,
+      innerStyle: {
+        width: t.width
+      },
+      ref: e,
+      innerClass: ["absolute top-full left-50% bg-dropMenu rounded-lg p-2 z-10 flex gap-2 translate-x--50% backdrop-blur-8", !t.row && "flex-col", t.innerClass]
+    }, {
+      default: () => t.options.map((n, l) => r("div", {
+        key: l,
+        class: "w-full min-w-max flex items-center justify-center px-4 py-2 rounded-lg bg-avatarMenuButton transition-colors",
+        onClick: () => {
+          e.value?.setShow(!1), n.action();
+        }
+      }, [n.label])),
+      trigger: o.trigger
+    });
+  }
+});
+export {
+  s as default
+};

package/dist/components/GlobalElementsContainer/ForegroundTask.d.ts

@@ -0,0 +1,39 @@
+import { type MaybeRef, type Ref } from 'vue';
+interface Task {
+    id: symbol;
+    name: MaybeRef<string>;
+    promise: Promise<any>;
+    status: 'pending' | 'success' | 'error';
+    error?: any;
+}
+export declare const foregroundTask: {
+    tasks: Ref<{
+        id: symbol;
+        name: string;
+        promise: {
+            then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        status: "pending" | "success" | "error";
+        error?: any;
+    }[], Task[] | {
+        id: symbol;
+        name: string;
+        promise: {
+            then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        status: "pending" | "success" | "error";
+        error?: any;
+    }[]>;
+    showErrorModal: Ref<boolean, boolean>;
+    currentError: Ref<any, any>;
+    register<T>(name: MaybeRef<string>, promise: Promise<T>): Promise<T>;
+    removeTask(id: symbol): void;
+};
+declare const _default: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/GlobalElementsContainer/ForegroundTask.js

@@ -0,0 +1,52 @@
+import { ref as o, defineComponent as l, createVNode as n, Transition as i } from "vue";
+const e = {
+  tasks: o([]),
+  showErrorModal: o(!1),
+  currentError: o(null),
+  async register(r, s) {
+    const a = {
+      id: Symbol(),
+      name: r,
+      promise: s,
+      status: "pending"
+    };
+    e.tasks.value.push(a);
+    try {
+      await s, a.status = "success";
+    } catch (t) {
+      throw a.status = "error", a.error = t, e.currentError.value = t, console.error(t), t;
+    } finally {
+      e.removeTask(a.id);
+    }
+    return console.log("Task completed:", a.name), await s;
+  },
+  removeTask(r) {
+    const s = e.tasks.value.findIndex((a) => a.id === r);
+    s !== -1 && e.tasks.value.splice(s, 1);
+  }
+}, c = /* @__PURE__ */ l({
+  setup() {
+    return () => n(i, {
+      duration: {
+        enter: 500,
+        leave: 500
+      },
+      leaveActiveClass: "transition-opacity duration-500 transition-ease-in-out",
+      leaveFromClass: "opacity-100",
+      leaveToClass: "opacity-0",
+      enterActiveClass: "transition-opacity duration-500 transition-ease-in-out",
+      enterToClass: "opacity-100",
+      enterFromClass: "opacity-0"
+    }, {
+      default: () => [!!e.tasks.value.length && n("div", {
+        class: "full bg-foregroundTask backdrop-blur-lg flex flex-col items-center justify-center gap-14 z-40"
+      }, [n("div", {
+        class: "op-90"
+      }, [typeof e.tasks.value[0].name == "string" ? e.tasks.value[0].name : e.tasks.value[0].name.value])])]
+    });
+  }
+});
+export {
+  c as default,
+  e as foregroundTask
+};

package/dist/components/GlobalElementsContainer/TaskManager.d.ts

@@ -0,0 +1,45 @@
+import { type MaybeRef, type Ref } from 'vue';
+interface Task {
+    id: symbol;
+    name: MaybeRef<string>;
+    promise: Promise<any>;
+    startTime: number;
+    status: 'pending' | 'success' | 'error';
+    error?: any;
+    showTimer?: number;
+}
+export declare const taskManager: {
+    tasks: Ref<{
+        id: symbol;
+        name: string;
+        promise: {
+            then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        startTime: number;
+        status: "pending" | "success" | "error";
+        error?: any;
+        showTimer?: number | undefined;
+    }[], Task[] | {
+        id: symbol;
+        name: string;
+        promise: {
+            then: <TResult1 = any, TResult2 = never>(onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined) => Promise<any>;
+            finally: (onfinally?: (() => void) | null | undefined) => Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        startTime: number;
+        status: "pending" | "success" | "error";
+        error?: any;
+        showTimer?: number | undefined;
+    }[]>;
+    showErrorModal: Ref<boolean, boolean>;
+    currentError: Ref<any, any>;
+    register<T>(name: MaybeRef<string>, promise: Promise<T>): Promise<T>;
+    removeTask(id: symbol): void;
+};
+declare const _default: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;