@echolab-auto/echo-prodoc 0.1.0

package/vendor/@echolab/ui-frame/dist/composables/useFormValidation.js

@@ -0,0 +1,44 @@
+const f = {
+  formRequired: "必填字段",
+  formMinLength: "最少 {min} 个字符",
+  formMaxLength: "最多 {max} 个字符",
+  formPattern: "格式不正确",
+  formMin: "不能小于 {min}",
+  formMax: "不能大于 {max}",
+  formValidator: "验证失败"
+};
+function o(r, m) {
+  return m ? r.replace(/\{(\w+)\}/g, (e, t) => String(m[t] ?? `{${t}}`)) : r;
+}
+function g(r, m, e) {
+  const t = (n, i) => o((e == null ? void 0 : e[n]) ?? f[n], i);
+  for (const n of m) {
+    if (n.required && (r == null || r === ""))
+      return n.message || t("formRequired");
+    if (!(r == null || r === "")) {
+      if (typeof r == "string") {
+        if (n.minLength && r.length < n.minLength)
+          return n.message || t("formMinLength", { min: n.minLength });
+        if (n.maxLength && r.length > n.maxLength)
+          return n.message || t("formMaxLength", { max: n.maxLength });
+        if (n.pattern && !n.pattern.test(r))
+          return n.message || t("formPattern");
+      }
+      if (typeof r == "number") {
+        if (n.min !== void 0 && r < n.min)
+          return n.message || t("formMin", { min: n.min });
+        if (n.max !== void 0 && r > n.max)
+          return n.message || t("formMax", { max: n.max });
+      }
+      if (n.validator) {
+        const i = n.validator(r);
+        if (typeof i == "string") return i;
+        if (i === !1) return n.message || t("formValidator");
+      }
+    }
+  }
+  return "";
+}
+export {
+  g as validateFieldValue
+};

package/vendor/@echolab/ui-frame/dist/composables/useLocale.d.ts

@@ -0,0 +1,38 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { LocaleMessages, Locale } from '../locales/types';
+
+declare const LocaleKey: InjectionKey<ComputedRef<LocaleMessages>>;
+/**
+ * Returns the active locale messages.
+ *
+ * Priority:
+ *   1. Explicitly provided locale via `provideLocale()`
+ *   2. Default zh-CN
+ *
+ * Use `t('key')` for messages with interpolation:
+ *   t('badgeUnread', { count: 5 }) // '未读 5'
+ *
+ * Or access directly:
+ *   locale.badgeOnline // '在线'
+ */
+export declare function useLocale(): {
+    locale: ComputedRef<LocaleMessages>;
+    t: (key: keyof LocaleMessages, params?: Record<string, string | number>) => string;
+};
+/**
+ * Provide a custom locale to all child components.
+ *
+ * @example
+ * ```ts
+ * import { provideLocale } from '@echolab/ui-frame'
+ * import { zhCN } from '@echolab/ui-frame/locales'
+ *
+ * provideLocale(zhCN)
+ * ```
+ */
+export declare function provideLocale(messages: LocaleMessages): void;
+/**
+ * Get locale messages by locale code.
+ */
+export declare function getLocaleMessages(locale: Locale): LocaleMessages;
+export { LocaleKey };

package/vendor/@echolab/ui-frame/dist/composables/useLocale.js

@@ -0,0 +1,34 @@
+import { inject as l, computed as r, provide as f } from "vue";
+import { zhCN as c, enUS as L } from "../locales/index.js";
+const p = {
+  "zh-CN": c,
+  "en-US": L
+}, i = Symbol("nm-locale"), u = c;
+function a(n, o) {
+  return n ? o ? n.replace(/\{(\w+)\}/g, (e, t) => String(o[t] ?? `{${t}}`)) : n : "";
+}
+function C() {
+  const n = l(
+    i,
+    r(() => u)
+  );
+  function o(e, t) {
+    return a(n.value[e], t);
+  }
+  return { locale: n, t: o };
+}
+function S(n) {
+  f(
+    i,
+    r(() => n)
+  );
+}
+function d(n) {
+  return p[n] ?? u;
+}
+export {
+  i as LocaleKey,
+  d as getLocaleMessages,
+  S as provideLocale,
+  C as useLocale
+};

package/vendor/@echolab/ui-frame/dist/composables/useMenu.d.ts

@@ -0,0 +1,55 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface MenuItem {
+    key: string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    children?: MenuItem[];
+    divided?: boolean;
+}
+export interface UseMenuOptions {
+    /** Flat or nested menu items */
+    items: Ref<MenuItem[]> | ComputedRef<MenuItem[]>;
+    /** Layout direction */
+    mode?: Ref<'vertical' | 'horizontal'>;
+    /** Initial active key (controlled: pass a Ref) */
+    activeKey?: Ref<string | null>;
+    /** Initial expanded submenu keys (controlled: pass a Ref) */
+    expandedKeys?: Ref<string[]>;
+    /** Called when an item is selected */
+    onSelect?: (item: MenuItem) => void;
+    /** Whether the menu is disabled entirely */
+    disabled?: Ref<boolean>;
+}
+export interface UseMenuReturn {
+    /** Currently active (focused/highlighted) key */
+    activeKey: Ref<string | null>;
+    /** Currently expanded submenu keys */
+    expandedKeys: Ref<string[]>;
+    /** All leaf keys in the menu tree */
+    allKeys: ComputedRef<string[]>;
+    /** Handle keyboard events */
+    handleKeydown: (event: KeyboardEvent) => void;
+    /** Handle item click */
+    handleItemClick: (item: MenuItem) => void;
+    /** Handle item hover/focus (used in horizontal mode) */
+    handleItemEnter: (item: MenuItem) => void;
+    /** Handle item leave (used in horizontal mode for submenus) */
+    handleItemLeave: (item: MenuItem) => void;
+    /** Check if a key is currently expanded */
+    isExpanded: (key: string) => boolean;
+    /** Check if a key is the active one */
+    isActive: (key: string) => boolean;
+    /** Expand a submenu */
+    expand: (key: string) => void;
+    /** Collapse a submenu */
+    collapse: (key: string) => void;
+    /** Toggle a submenu */
+    toggleExpand: (key: string) => void;
+}
+/**
+ * Headless menu — encapsulates active-item tracking, keyboard navigation,
+ * submenu expansion, typeahead search, and mode-aware arrow key behaviour.
+ */
+export declare function useMenu(opts: UseMenuOptions): UseMenuReturn;

package/vendor/@echolab/ui-frame/dist/composables/useMenu.js

@@ -0,0 +1,218 @@
+import { ref as p, watch as g, nextTick as b, computed as x } from "vue";
+function C(a, u, t = []) {
+  var r;
+  for (const i of a)
+    t.push(i), (r = i.children) != null && r.length && u.includes(i.key) && C(i.children, u, t);
+  return t;
+}
+function J(a) {
+  const u = [];
+  function t(r) {
+    var i;
+    for (const n of r)
+      u.push(n.key), (i = n.children) != null && i.length && t(n.children);
+  }
+  return t(a), u;
+}
+function K(a, u) {
+  var t;
+  for (const r of a) {
+    if (r.key === u) return r;
+    if ((t = r.children) != null && t.length) {
+      const i = K(r.children, u);
+      if (i) return i;
+    }
+  }
+  return null;
+}
+function M(a, u = null, t = /* @__PURE__ */ new Map()) {
+  var r;
+  for (const i of a)
+    t.set(i.key, u), (r = i.children) != null && r.length && M(i.children, i.key, t);
+  return t;
+}
+function z(a, u) {
+  if (a.length !== u.length) return !1;
+  for (let t = 0; t < a.length; t++)
+    if (a[t] !== u[t]) return !1;
+  return !0;
+}
+function X(a) {
+  const { items: u, onSelect: t } = a, r = a.mode ?? p("vertical"), i = a.disabled ?? p(!1), n = p(null), f = p([]);
+  let o = !1;
+  a.activeKey && (g(
+    () => a.activeKey.value,
+    (e) => {
+      o || n.value !== e && (o = !0, n.value = e, b(() => {
+        o = !1;
+      }));
+    },
+    { immediate: !0 }
+  ), g(
+    () => n.value,
+    (e) => {
+      o || a.activeKey.value !== e && (o = !0, a.activeKey.value = e, b(() => {
+        o = !1;
+      }));
+    }
+  ));
+  let d = !1;
+  a.expandedKeys && (g(
+    () => a.expandedKeys.value,
+    (e) => {
+      d || z(f.value, e) || (d = !0, f.value = [...e], b(() => {
+        d = !1;
+      }));
+    },
+    { immediate: !0, deep: !0 }
+  ), g(
+    () => f.value,
+    (e) => {
+      d || z(a.expandedKeys.value, e) || (d = !0, a.expandedKeys.value = [...e], b(() => {
+        d = !1;
+      }));
+    },
+    { deep: !0 }
+  ));
+  const N = x(() => J(u.value)), F = x(() => C(u.value, f.value)), V = x(() => M(u.value)), v = x(() => F.value.filter((e) => !e.disabled));
+  function y(e) {
+    return f.value.includes(e);
+  }
+  function H(e) {
+    return n.value === e;
+  }
+  function k(e) {
+    f.value.includes(e) || f.value.push(e);
+  }
+  function w(e) {
+    const l = f.value.indexOf(e);
+    l !== -1 && f.value.splice(l, 1);
+  }
+  function D(e) {
+    y(e) ? w(e) : k(e);
+  }
+  function O(e) {
+    var l;
+    i.value || e.disabled || ((l = e.children) != null && l.length ? D(e.key) : (n.value = e.key, t == null || t(e)));
+  }
+  function _(e) {
+    var l;
+    i.value || e.disabled || (r.value === "horizontal" && ((l = e.children) != null && l.length) && k(e.key), n.value = e.key);
+  }
+  function q(e) {
+    var l;
+    i.value || e.disabled || r.value === "horizontal" && ((l = e.children) != null && l.length);
+  }
+  let m = "", A = null;
+  function B(e) {
+    m += e.toLowerCase(), A && clearTimeout(A), A = setTimeout(() => {
+      m = "";
+    }, 500);
+    const l = v.value, c = n.value ? l.findIndex((E) => E.key === n.value) + 1 : 0, s = [...l.slice(c), ...l.slice(0, c)].find((E) => E.label.toLowerCase().startsWith(m));
+    s && (n.value = s.key);
+  }
+  function I() {
+    const e = v.value;
+    if (!e.length) return;
+    if (!n.value) {
+      n.value = e[0].key;
+      return;
+    }
+    const l = e.findIndex((c) => c.key === n.value);
+    l >= 0 && l < e.length - 1 ? n.value = e[l + 1].key : n.value = e[0].key;
+  }
+  function L() {
+    const e = v.value;
+    if (!e.length) return;
+    if (!n.value) {
+      n.value = e[e.length - 1].key;
+      return;
+    }
+    const l = e.findIndex((c) => c.key === n.value);
+    l > 0 ? n.value = e[l - 1].key : n.value = e[e.length - 1].key;
+  }
+  function R() {
+    const e = v.value;
+    e.length && (n.value = e[0].key);
+  }
+  function U() {
+    const e = v.value;
+    e.length && (n.value = e[e.length - 1].key);
+  }
+  function W() {
+    if (!n.value) return;
+    const e = V.value.get(n.value);
+    e && (n.value = e);
+  }
+  function P() {
+    var l;
+    if (!n.value) return;
+    const e = K(u.value, n.value);
+    (l = e == null ? void 0 : e.children) != null && l.length && (y(e.key) || k(e.key), n.value = e.children[0].key);
+  }
+  function T() {
+    var l;
+    if (!n.value) return;
+    const e = K(u.value, n.value);
+    (l = e == null ? void 0 : e.children) != null && l.length && y(e.key) ? w(e.key) : W();
+  }
+  function j() {
+    var l;
+    if (!n.value) return;
+    const e = K(u.value, n.value);
+    !e || e.disabled || ((l = e.children) != null && l.length ? D(e.key) : t == null || t(e));
+  }
+  function G(e) {
+    if (i.value) return;
+    const l = e.key;
+    if (l.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+      B(l), e.preventDefault();
+      return;
+    }
+    const h = r.value === "vertical", s = r.value === "horizontal";
+    switch (l) {
+      case "ArrowDown":
+        h ? I() : s && P(), e.preventDefault();
+        break;
+      case "ArrowUp":
+        h ? L() : s && T(), e.preventDefault();
+        break;
+      case "ArrowRight":
+        h ? P() : s && I(), e.preventDefault();
+        break;
+      case "ArrowLeft":
+        h ? T() : s && L(), e.preventDefault();
+        break;
+      case "Enter":
+      case " ":
+        j(), e.preventDefault();
+        break;
+      case "Escape":
+        f.value = [], n.value = null, e.preventDefault();
+        break;
+      case "Home":
+        R(), e.preventDefault();
+        break;
+      case "End":
+        U(), e.preventDefault();
+        break;
+    }
+  }
+  return {
+    activeKey: n,
+    expandedKeys: f,
+    allKeys: N,
+    handleKeydown: G,
+    handleItemClick: O,
+    handleItemEnter: _,
+    handleItemLeave: q,
+    isExpanded: y,
+    isActive: H,
+    expand: k,
+    collapse: w,
+    toggleExpand: D
+  };
+}
+export {
+  X as useMenu
+};

package/vendor/@echolab/ui-frame/dist/composables/useModal.d.ts

@@ -0,0 +1,31 @@
+import { Ref } from 'vue';
+
+export interface UseModalOptions {
+    /** v-model visibility */
+    modelValue: Ref<boolean>;
+    /** Whether clicking the mask closes the modal */
+    maskClosable?: Ref<boolean>;
+    /** Whether the modal can be closed */
+    closable?: Ref<boolean>;
+    /** Whether to destroy DOM when closed */
+    destroyOnClose?: Ref<boolean>;
+}
+export interface UseModalReturn {
+    /** Whether the modal is currently visible (for transitions) */
+    visible: Ref<boolean>;
+    /** Whether the modal DOM should be rendered */
+    rendered: Ref<boolean>;
+    /** Close the modal */
+    close: () => void;
+    /** Confirm action */
+    confirm: () => void;
+    /** Handle keydown for Escape and focus trap */
+    handleKeydown: (event: KeyboardEvent, dialogEl: HTMLElement | undefined) => void;
+    /** Focus the first focusable element inside the dialog (call after dialog mounts) */
+    focusDialog: (dialogEl: HTMLElement | undefined) => void;
+}
+/**
+ * Headless modal — encapsulates open/close, body scroll lock, focus
+ * trap, and Escape handling. Use with your own UI rendering.
+ */
+export declare function useModal(opts: UseModalOptions): UseModalReturn;

package/vendor/@echolab/ui-frame/dist/composables/useModal.js

@@ -0,0 +1,93 @@
+import { ref as c, watch as C, nextTick as h, onMounted as M, onBeforeUnmount as W } from "vue";
+const d = /* @__PURE__ */ new WeakMap();
+function p(o) {
+  return d.get(o) ?? 0;
+}
+function k(o, n) {
+  n <= 0 ? d.delete(o) : d.set(o, n);
+}
+function E() {
+  return typeof window > "u" ? 0 : window.innerWidth - document.documentElement.clientWidth;
+}
+function A(o) {
+  const { modelValue: n } = o, m = o.closable ?? c(!0), w = o.destroyOnClose ?? c(!1), l = c(n.value), i = c(n.value), s = c(null);
+  let a;
+  function g() {
+    if (typeof document > "u") return;
+    const e = p(document);
+    if (k(document, e + 1), e === 0) {
+      const t = E();
+      t > 0 && (document.body.style.paddingRight = `${t}px`), document.body.style.overflow = "hidden";
+    }
+  }
+  function v() {
+    if (typeof document > "u") return;
+    const e = p(document), t = Math.max(0, e - 1);
+    k(document, t), t === 0 && (document.body.style.overflow = "", document.body.style.paddingRight = "");
+  }
+  C(
+    () => n.value,
+    (e) => {
+      var t;
+      if (e) {
+        i.value = !0;
+        const u = document.activeElement;
+        s.value = u instanceof HTMLElement ? u : null, g(), h(() => {
+          l.value = !0;
+        });
+      } else
+        l.value = !1, clearTimeout(a), w.value && (a = setTimeout(() => {
+          i.value = !1;
+        }, 200)), v(), (t = s.value) == null || t.focus();
+    }
+  );
+  function b() {
+    m.value && (n.value = !1);
+  }
+  function x() {
+    n.value = !1;
+  }
+  function y(e) {
+    return e ? Array.from(
+      e.querySelectorAll(
+        'button:not([disabled]), [href]:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"]):not([disabled]), [contenteditable]:not([contenteditable="false"])'
+      )
+    ) : [];
+  }
+  function T(e) {
+    if (!e) return;
+    e.focus();
+    const t = y(e);
+    t.length > 0 && t[0].focus();
+  }
+  function S(e, t) {
+    if (e.key === "Escape" && m.value) {
+      b();
+      return;
+    }
+    if (e.key === "Tab" && t) {
+      const u = y(t);
+      if (u.length === 0) return;
+      const r = u[0], f = u[u.length - 1];
+      e.shiftKey ? document.activeElement === r && (e.preventDefault(), f == null || f.focus()) : document.activeElement === f && (e.preventDefault(), r == null || r.focus());
+    }
+  }
+  return M(() => {
+    n.value && (i.value = !0, h(() => {
+      l.value = !0;
+    }));
+  }), W(() => {
+    var e;
+    clearTimeout(a), v(), l.value && ((e = s.value) == null || e.focus());
+  }), {
+    visible: l,
+    rendered: i,
+    close: b,
+    confirm: x,
+    handleKeydown: S,
+    focusDialog: T
+  };
+}
+export {
+  A as useModal
+};

package/vendor/@echolab/ui-frame/dist/composables/useNumberInput.d.ts

@@ -0,0 +1,52 @@
+import { Ref, ComputedRef } from 'vue';
+
+/**
+ * Options for the useNumberInput composable.
+ */
+export interface UseNumberInputOptions {
+    /** v-model value — a writable Ref<number | undefined> */
+    modelValue: Ref<number | undefined>;
+    /** Minimum allowed value (default: -Infinity) */
+    min?: number;
+    /** Maximum allowed value (default: Infinity) */
+    max?: number;
+    /** Step increment for up/down buttons and keyboard (default: 1) */
+    step?: number;
+    /** Decimal precision (default: inferred from step) */
+    precision?: number;
+    /** Whether the input is disabled */
+    disabled?: Ref<boolean>;
+}
+/**
+ * Return type for the useNumberInput composable.
+ */
+export interface UseNumberInputReturn {
+    /** Display value as a string, bound to the input field */
+    displayValue: ComputedRef<string>;
+    /** Increment the value by step */
+    increment: () => void;
+    /** Decrement the value by step */
+    decrement: () => void;
+    /** Programmatically set the numeric value */
+    setValue: (value: number) => void;
+    /** Keyboard event handler (ArrowUp/ArrowDown) */
+    handleKeydown: (event: KeyboardEvent) => void;
+    /** Input handler — update display buffer without committing */
+    handleInput: (event: Event) => void;
+    /** Blur handler — formats and commits display value */
+    handleBlur: () => void;
+}
+/**
+ * Format a numeric value to a string using the given precision.
+ */
+export declare function formatNumber(value: number | undefined, precision: number): string;
+/**
+ * Parse a string value to a number, returning undefined on invalid input.
+ */
+export declare function parseNumber(str: string): number | undefined;
+/**
+ * Headless number input — encapsulates value clamping, step precision,
+ * keyboard navigation, increment/decrement, and parse/format logic
+ * without any rendering. Use with your own UI.
+ */
+export declare function useNumberInput(opts: UseNumberInputOptions): UseNumberInputReturn;

package/vendor/@echolab/ui-frame/dist/composables/useNumberInput.js

@@ -0,0 +1,100 @@
+import { computed as w, ref as g, watch as D } from "vue";
+function v(r, n, e) {
+  return Math.min(Math.max(r, n), e);
+}
+function y(r, n) {
+  const e = Math.pow(10, n);
+  return Math.round(r * e) / e;
+}
+function F(r) {
+  if (!Number.isFinite(r) || r <= 0) return 0;
+  const n = String(r), e = n.indexOf(".");
+  return e === -1 ? 0 : n.length - e - 1;
+}
+function m(r, n) {
+  return r == null || !Number.isFinite(r) ? "" : y(r, n).toFixed(n);
+}
+function k(r) {
+  const n = r.trim();
+  if (n === "" || n === "-" || n === "+") return;
+  const e = Number(n);
+  return Number.isFinite(e) ? e : void 0;
+}
+function A(r) {
+  const {
+    modelValue: n,
+    min: e = -1 / 0,
+    max: s = 1 / 0,
+    step: c = 1,
+    precision: d,
+    disabled: o
+  } = r, a = w(() => d !== void 0 ? d : F(c)), i = g(m(n.value, a.value)), I = w(() => i.value);
+  D(n, (t) => {
+    const u = m(t, a.value);
+    k(i.value) !== t && (i.value = u);
+  });
+  function p(t) {
+    if (c <= 0) return t;
+    const u = a.value, f = Math.round((t - e) / c) * c + e;
+    return y(f, u);
+  }
+  function l(t) {
+    if (o != null && o.value) return;
+    const u = v(t, e, s), f = p(u);
+    n.value = f, i.value = m(f, a.value);
+  }
+  function h() {
+    const t = n.value ?? e, u = v(t + c, e, s);
+    l(p(u));
+  }
+  function x() {
+    const t = n.value ?? s, u = v(t - c, e, s);
+    l(p(u));
+  }
+  function M(t) {
+    if (!(o != null && o.value))
+      switch (t.key) {
+        case "ArrowUp": {
+          t.preventDefault(), h();
+          break;
+        }
+        case "ArrowDown": {
+          t.preventDefault(), x();
+          break;
+        }
+        case "Enter": {
+          t.preventDefault(), N();
+          break;
+        }
+      }
+  }
+  function b(t) {
+    if (o != null && o.value) return;
+    const u = t.target;
+    i.value = u.value;
+  }
+  function N() {
+    if (o != null && o.value) return;
+    const t = k(i.value);
+    if (t === void 0) {
+      const u = n.value ?? e;
+      i.value = m(u, a.value);
+      return;
+    }
+    l(t);
+  }
+  return {
+    displayValue: I,
+    increment: h,
+    decrement: x,
+    setValue: l,
+    handleInput: b,
+    handleKeydown: M,
+    handleBlur: N
+  };
+}
+export {
+  m as formatNumber,
+  k as parseNumber,
+  A as useNumberInput
+};