@echolab-auto/echo-prodoc 0.1.0

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

@@ -0,0 +1,243 @@
+import { ComputedRef, InjectionKey } from 'vue';
+
+export interface NeumorphismGlobalConfig {
+    /** Default button props applied to all NeumorphismButton instances */
+    button?: {
+        variant?: 'raised' | 'flat' | 'pressed';
+        size?: 'small' | 'medium' | 'large';
+        shape?: 'rounded' | 'pill' | 'circle';
+    };
+    /** Default input props applied to all NeumorphismInput instances */
+    input?: {
+        size?: 'small' | 'medium' | 'large';
+    };
+    /** Default date picker props */
+    datePicker?: {
+        size?: 'small' | 'medium' | 'large';
+        format?: string;
+        clearable?: boolean;
+        firstDayOfWeek?: number;
+        placeholder?: string;
+    };
+    /** Default select props */
+    select?: {
+        size?: 'small' | 'medium' | 'large';
+        clearable?: boolean;
+        emptyText?: string;
+        placeholder?: string;
+    };
+    /** Default modal props */
+    modal?: {
+        size?: 'small' | 'medium' | 'large';
+        maskClosable?: boolean;
+        closable?: boolean;
+        showClose?: boolean;
+        destroyOnClose?: boolean;
+    };
+    /** Default toast props */
+    toast?: {
+        position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center';
+        maxCount?: number;
+    };
+    /** Default tooltip props */
+    tooltip?: {
+        position?: 'top' | 'bottom' | 'left' | 'right';
+        trigger?: 'hover' | 'click' | 'focus';
+        offset?: number;
+        delay?: number;
+    };
+    /** Default tabs props */
+    tabs?: {
+        position?: 'top' | 'left' | 'right';
+        size?: 'small' | 'medium' | 'large';
+    };
+    /** Default pagination props */
+    pagination?: {
+        size?: 'small' | 'medium' | 'large';
+        showTotal?: boolean;
+        showJumper?: boolean;
+        maxVisiblePages?: number;
+        pageSize?: number;
+    };
+    /** Default collapse props */
+    collapse?: {
+        size?: 'small' | 'medium' | 'large';
+        accordion?: boolean;
+    };
+    /** Default form props */
+    form?: {
+        size?: 'small' | 'medium' | 'large';
+        labelWidth?: string;
+        direction?: 'horizontal' | 'vertical';
+    };
+    /** Default tag props */
+    tag?: {
+        variant?: 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+        size?: 'small' | 'medium' | 'large';
+        rounded?: boolean;
+    };
+    /** Default progress props */
+    progress?: {
+        variant?: 'primary' | 'success' | 'warning' | 'error';
+        size?: 'small' | 'medium' | 'large';
+        showLabel?: boolean;
+    };
+    /** Default avatar props */
+    avatar?: {
+        size?: 'small' | 'medium' | 'large';
+        shape?: 'circle' | 'rounded';
+    };
+    /** Default tree props */
+    tree?: {
+        showSearch?: boolean;
+        multiple?: boolean;
+        searchPlaceholder?: string;
+    };
+    /** Default switch props */
+    switch?: {
+        size?: 'small' | 'medium' | 'large';
+    };
+    /** Default table props */
+    table?: {
+        size?: 'small' | 'medium' | 'large';
+        striped?: boolean;
+        hoverable?: boolean;
+    };
+    /** Default card props */
+    card?: {
+        radius?: 'small' | 'medium' | 'large' | 'xl';
+        hoverable?: boolean | 'bulge' | 'sink';
+    };
+    /** Default badge props */
+    badge?: {
+        max?: number;
+        dot?: boolean;
+        showZero?: boolean;
+    };
+    /** Default breadcrumb props */
+    breadcrumb?: {
+        size?: 'small' | 'medium' | 'large';
+        separator?: string;
+    };
+    /** Default checkbox props */
+    checkbox?: {
+        size?: 'small' | 'medium' | 'large';
+    };
+    /** Default radio props */
+    radio?: {
+        size?: 'small' | 'medium' | 'large';
+    };
+    /** Default radio group props */
+    radioGroup?: {
+        size?: 'small' | 'medium' | 'large';
+        direction?: 'horizontal' | 'vertical';
+    };
+    /** Default textarea props */
+    textarea?: {
+        size?: 'small' | 'medium' | 'large';
+        rows?: number;
+        autoResize?: boolean;
+        showCount?: boolean;
+    };
+    /** Default divider props */
+    divider?: {
+        direction?: 'horizontal' | 'vertical';
+        align?: 'left' | 'center' | 'right';
+        dashed?: boolean;
+        inset?: boolean;
+    };
+    /** Default container props */
+    container?: {
+        mode?: 'fixed' | 'fluid';
+        noPadding?: boolean;
+    };
+    /** Default layout props */
+    layout?: {
+        showHeader?: boolean;
+        showSider?: boolean;
+        siderWidth?: number;
+        collapsible?: boolean;
+        collapsedWidth?: number;
+        mobileAutoCollapse?: boolean;
+    };
+    /** Default theme toggle props */
+    themeToggle?: {
+        size?: 'small' | 'medium' | 'large';
+        disableAuto?: boolean;
+    };
+    /** Default canvas props */
+    canvas?: {
+        showGrid?: boolean;
+        gridSize?: number;
+        showControls?: boolean;
+    };
+    /** Default skeleton props */
+    skeleton?: {
+        variant?: 'text' | 'circle' | 'rect';
+        animation?: 'pulse' | 'wave' | 'none';
+    };
+    /** Default grid props */
+    grid?: {
+        gutter?: number | [number, number];
+        justify?: 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly';
+        align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+        wrap?: boolean;
+    };
+    /** Default field props */
+    field?: {
+        labelWidth?: string;
+    };
+    /** Default slider props */
+    slider?: {
+        size?: 'small' | 'medium' | 'large';
+        showTooltip?: boolean;
+        showStops?: boolean;
+    };
+    /** Default steps props */
+    steps?: {
+        direction?: 'horizontal' | 'vertical';
+        size?: 'small' | 'medium' | 'large';
+        center?: boolean;
+    };
+    /** Default upload props */
+    upload?: {
+        size?: 'small' | 'medium' | 'large';
+        drag?: boolean;
+        showUploadList?: boolean;
+        listType?: 'text' | 'picture' | 'picture-card';
+        autoUpload?: boolean;
+    };
+    /** Default list props */
+    list?: {
+        bordered?: boolean;
+        split?: boolean;
+        size?: 'small' | 'medium' | 'large';
+        hoverable?: boolean;
+    };
+    /** Locale configuration */
+    locale?: 'zh-CN' | 'en-US';
+    /** Custom locale messages (overrides built-in locale) */
+    localeMessages?: import('../locales/types').LocaleMessages;
+    /** Default theme config */
+    theme?: {
+        defaultTheme?: 'light' | 'dark' | 'auto';
+        storageKey?: string;
+        followSystem?: boolean;
+    };
+    /** Whether to use RTL (right-to-left) direction */
+    rtl?: boolean;
+    /** Extension: consumers can add custom component config sections. */
+    [configSection: string]: unknown;
+}
+export declare const ConfigKey: InjectionKey<ComputedRef<NeumorphismGlobalConfig>>;
+/**
+ * Returns the global config merged with component-level defaults.
+ * Components should use this to resolve their props.
+ *
+ * @example
+ * ```ts
+ * const config = useConfig()
+ * const size = props.size ?? config.value.button?.size ?? 'medium'
+ * ```
+ */
+export declare function useConfig(): ComputedRef<NeumorphismGlobalConfig>;

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

@@ -0,0 +1,12 @@
+import { inject as o, computed as n } from "vue";
+const c = Symbol("nm-global-config"), t = {};
+function e() {
+  return o(
+    c,
+    n(() => t)
+  );
+}
+export {
+  c as ConfigKey,
+  e as useConfig
+};

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

@@ -0,0 +1,73 @@
+import { Ref, ComputedRef } from 'vue';
+
+/** A single day cell in the calendar grid */
+export interface DayCell {
+    /** Full Date object for this cell */
+    date: Date;
+    /** Day of month (1-31) */
+    day: number;
+    /** Whether this cell belongs to the currently displayed month */
+    isCurrentMonth: boolean;
+    /** Whether this cell represents today */
+    isToday: boolean;
+    /** Whether this cell is currently selected */
+    isSelected: boolean;
+    /** Whether this cell is disabled (outside min/max bounds) */
+    isDisabled: boolean;
+    /** Whether this cell falls within a selected range (for future range support) */
+    isInRange: boolean;
+}
+export interface UseDatePickerOptions {
+    /** v-model value — the selected date */
+    modelValue: Ref<Date | null>;
+    /** Minimum selectable date */
+    minDate?: Ref<Date | undefined> | Date;
+    /** Maximum selectable date */
+    maxDate?: Ref<Date | undefined> | Date;
+    /** Display format string (e.g. 'yyyy-MM-dd') */
+    format?: Ref<string | undefined> | string;
+    /** First day of week (0 = Sunday, 1 = Monday) */
+    firstDayOfWeek?: Ref<number | undefined> | number;
+}
+export interface UseDatePickerReturn {
+    /** Currently displayed year */
+    currentYear: Ref<number>;
+    /** Currently displayed month (1-based) */
+    currentMonth: Ref<number>;
+    /** Flat array of 42 day cells for the calendar grid (6 rows x 7 cols) */
+    calendarDays: ComputedRef<DayCell[]>;
+    /** Array of weekday header labels */
+    weekdays: ComputedRef<string[]>;
+    /** The currently selected date (from modelValue) */
+    selectedDate: ComputedRef<Date | null>;
+    /** Select a date */
+    selectDate: (date: Date) => void;
+    /** Navigate to previous month */
+    prevMonth: () => void;
+    /** Navigate to next month */
+    nextMonth: () => void;
+    /** Navigate to previous year */
+    prevYear: () => void;
+    /** Navigate to next year */
+    nextYear: () => void;
+    /** Check if a date is the selected date */
+    isSelected: (date: Date) => boolean;
+    /** Check if a date is today */
+    isToday: (date: Date) => boolean;
+    /** Check if a date falls within a potential range (for future range support) */
+    isInRange: (date: Date) => boolean;
+    /** Check if a date is disabled (outside min/max bounds) */
+    isDisabled: (date: Date) => boolean;
+    /** Format a date to display string using the configured format */
+    formatDate: (date: Date | null) => string;
+    /** Navigate to today's month/year */
+    goToToday: () => void;
+}
+/**
+ * Headless date picker — encapsulates calendar state, navigation, day cell
+ * computation, date validation, and formatting without any rendering.
+ *
+ * Use with your own UI. The `NeumorphismDatePicker` component provides
+ * a ready-to-use neumorphism-styled implementation.
+ */
+export declare function useDatePicker(opts: UseDatePickerOptions): UseDatePickerReturn;

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

@@ -0,0 +1,118 @@
+import { computed as i, ref as Y } from "vue";
+function F(t, n, d) {
+  const r = new Date(t, n - 1, d);
+  return r.setHours(0, 0, 0, 0), r;
+}
+function f(t) {
+  const n = new Date(t.getTime());
+  return n.setHours(0, 0, 0, 0), n;
+}
+function D(t, n) {
+  return !t || !n ? !1 : t.getFullYear() === n.getFullYear() && t.getMonth() === n.getMonth() && t.getDate() === n.getDate();
+}
+function G(t, n) {
+  return (t.getDay() - n + 7) % 7;
+}
+function J(t, n) {
+  const d = t.getFullYear(), r = t.getMonth() + 1, v = t.getDate();
+  return n.replace(/yyyy/g, String(d)).replace(/yy/g, String(d).slice(-2)).replace(/MM/g, String(r).padStart(2, "0")).replace(/M/g, String(r)).replace(/dd/g, String(v).padStart(2, "0")).replace(/d/g, String(v));
+}
+const N = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"];
+function Z(t) {
+  const { modelValue: n } = t, d = i(() => {
+    const e = t.format;
+    return typeof e == "object" && "value" in e ? e.value : e ?? "yyyy-MM-dd";
+  }), r = i(() => {
+    const e = t.firstDayOfWeek;
+    return typeof e == "object" && "value" in e ? e.value : e ?? 0;
+  }), v = i(() => {
+    const e = t.minDate;
+    if (e)
+      return e instanceof Date ? e : e.value;
+  }), M = i(() => {
+    const e = t.maxDate;
+    if (e)
+      return e instanceof Date ? e : e.value;
+  }), y = i(() => n.value), h = n.value ? f(n.value) : /* @__PURE__ */ new Date(), c = Y(h.getFullYear()), o = Y(h.getMonth() + 1), T = i(() => {
+    const e = c.value, a = o.value, s = r.value ?? 0, u = /* @__PURE__ */ new Date();
+    u.setHours(0, 0, 0, 0);
+    const C = y.value, S = v.value, p = M.value, _ = F(e, a, 1), K = G(_, s), I = [];
+    for (let g = 0; g < 42; g++) {
+      const L = g - K, l = F(e, a, 1 + L), P = l.getMonth() + 1, U = l.getFullYear(), V = P === a && U === e, q = D(l, u), z = D(l, C), B = (S ? l < f(S) : !1) || (p ? l > f(p) : !1);
+      I.push({
+        date: l,
+        day: l.getDate(),
+        isCurrentMonth: V,
+        isToday: q,
+        isSelected: z,
+        isDisabled: B,
+        isInRange: !1
+      });
+    }
+    return I;
+  }), w = i(() => {
+    const e = r.value ?? 0, a = [];
+    for (let s = 0; s < 7; s++) {
+      const u = (e + s) % 7;
+      a.push(N[u]);
+    }
+    return a;
+  });
+  function x() {
+    o.value === 1 ? (o.value = 12, c.value--) : o.value--;
+  }
+  function O() {
+    o.value === 12 ? (o.value = 1, c.value++) : o.value++;
+  }
+  function k() {
+    c.value--;
+  }
+  function R() {
+    c.value++;
+  }
+  function W() {
+    const e = /* @__PURE__ */ new Date();
+    c.value = e.getFullYear(), o.value = e.getMonth() + 1;
+  }
+  function H(e) {
+    m(e) || (n.value = f(e));
+  }
+  function b(e) {
+    return D(e, y.value);
+  }
+  function j(e) {
+    const a = /* @__PURE__ */ new Date();
+    return a.setHours(0, 0, 0, 0), D(e, a);
+  }
+  function E(e) {
+    return !1;
+  }
+  function m(e) {
+    const a = v.value, s = M.value, u = f(e);
+    return !!(a && u < f(a) || s && u > f(s));
+  }
+  function A(e) {
+    return e ? J(e, d.value ?? "yyyy-MM-dd") : "";
+  }
+  return {
+    currentYear: c,
+    currentMonth: o,
+    calendarDays: T,
+    weekdays: w,
+    selectedDate: y,
+    selectDate: H,
+    prevMonth: x,
+    nextMonth: O,
+    prevYear: k,
+    nextYear: R,
+    isSelected: b,
+    isToday: j,
+    isInRange: E,
+    isDisabled: m,
+    formatDate: A,
+    goToToday: W
+  };
+}
+export {
+  Z as useDatePicker
+};

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

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+
+export type DrawerPosition = 'left' | 'right' | 'top' | 'bottom';
+export interface UseDrawerOptions {
+    /** v-model visibility */
+    modelValue: Ref<boolean>;
+    /** Whether clicking the mask closes the drawer */
+    maskClosable?: Ref<boolean>;
+    /** Whether the drawer can be closed at all (Escape / close button) */
+    closable?: Ref<boolean>;
+    /** Whether to destroy DOM when closed */
+    destroyOnClose?: Ref<boolean>;
+}
+export interface UseDrawerReturn {
+    /** Whether the drawer is currently visible (for transitions) */
+    isOpen: Ref<boolean>;
+    /** Whether the drawer DOM should be rendered */
+    rendered: Ref<boolean>;
+    /** Open the drawer */
+    open: () => void;
+    /** Close the drawer */
+    close: () => void;
+    /** Handle keydown for Escape and focus trap */
+    handleKeydown: (event: KeyboardEvent, drawerEl: HTMLElement | undefined) => void;
+    /** Handle mask click — closes when maskClosable and closable */
+    handleMaskClick: () => void;
+    /** Focus the first focusable element inside the drawer (call after drawer mounts) */
+    focusDrawer: (drawerEl: HTMLElement | undefined) => void;
+}
+/**
+ * Headless drawer — encapsulates open/close, body scroll lock, focus trap,
+ * Escape handling, and mask click dismissal. Use with your own UI rendering.
+ */
+export declare function useDrawer(opts: UseDrawerOptions): UseDrawerReturn;

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

@@ -0,0 +1,97 @@
+import { ref as l, watch as W, nextTick as h, onMounted as D, onBeforeUnmount as E } from "vue";
+const v = /* @__PURE__ */ new WeakMap();
+function k(n) {
+  return v.get(n) ?? 0;
+}
+function p(n, o) {
+  o <= 0 ? v.delete(n) : v.set(n, o);
+}
+function L() {
+  return typeof window > "u" ? 0 : window.innerWidth - document.documentElement.clientWidth;
+}
+function B(n) {
+  const { modelValue: o } = n, g = n.maskClosable ?? l(!0), f = n.closable ?? l(!0), x = n.destroyOnClose ?? l(!1), c = l(o.value), i = l(o.value), r = l(null);
+  let d;
+  function C() {
+    if (typeof document > "u") return;
+    const e = k(document);
+    if (p(document, e + 1), e === 0) {
+      const t = L();
+      t > 0 && (document.body.style.paddingRight = `${t}px`), document.body.style.overflow = "hidden";
+    }
+  }
+  function b() {
+    if (typeof document > "u") return;
+    const e = k(document), t = Math.max(0, e - 1);
+    p(document, t), t === 0 && (document.body.style.overflow = "", document.body.style.paddingRight = "");
+  }
+  W(
+    () => o.value,
+    (e) => {
+      var t;
+      if (e) {
+        i.value = !0;
+        const u = document.activeElement;
+        r.value = u instanceof HTMLElement ? u : null, C(), h(() => {
+          c.value = !0;
+        });
+      } else
+        c.value = !1, clearTimeout(d), x.value && (d = setTimeout(() => {
+          i.value = !1;
+        }, 200)), b(), (t = r.value) == null || t.focus();
+    }
+  );
+  function w() {
+    o.value = !0;
+  }
+  function m() {
+    f.value && (o.value = !1);
+  }
+  function T() {
+    g.value && f.value && m();
+  }
+  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 S(e) {
+    if (!e) return;
+    e.focus();
+    const t = y(e);
+    t.length > 0 && t[0].focus();
+  }
+  function M(e, t) {
+    if (e.key === "Escape" && f.value) {
+      m();
+      return;
+    }
+    if (e.key === "Tab" && t) {
+      const u = y(t);
+      if (u.length === 0) return;
+      const a = u[0], s = u[u.length - 1];
+      e.shiftKey ? document.activeElement === a && (e.preventDefault(), s == null || s.focus()) : document.activeElement === s && (e.preventDefault(), a == null || a.focus());
+    }
+  }
+  return D(() => {
+    o.value && (i.value = !0, h(() => {
+      c.value = !0;
+    }));
+  }), E(() => {
+    var e;
+    clearTimeout(d), b(), c.value && ((e = r.value) == null || e.focus());
+  }), {
+    isOpen: c,
+    rendered: i,
+    open: w,
+    close: m,
+    handleKeydown: M,
+    handleMaskClick: T,
+    focusDrawer: S
+  };
+}
+export {
+  B as useDrawer
+};

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

@@ -0,0 +1,24 @@
+export type FieldSize = 'small' | 'medium' | 'large';
+export interface FormFieldConfig {
+    /** 组件 props */
+    id?: string;
+    size: 'small' | 'medium' | 'large';
+    disabled: boolean;
+    error?: string | boolean;
+    /** generateId 前缀  */
+    prefix: 'input' | 'textarea' | 'select' | 'datepicker';
+}
+/**
+ * Input/Textarea/Select 共享表单字段逻辑
+ */
+export declare function useFormField(config: () => FormFieldConfig): {
+    isFocused: import('vue').Ref<boolean, boolean>;
+    fieldId: string;
+    errorMessage: import('vue').ComputedRef<string>;
+    hasError: import('vue').ComputedRef<boolean>;
+    baseClassList: (baseClass: string) => import('vue').ComputedRef<(string | {
+        [x: string]: boolean;
+    })[]>;
+    handleFocus: (event: FocusEvent, emit: (e: "focus", ev: FocusEvent) => void) => void;
+    handleBlur: (event: FocusEvent, emit: (e: "blur", ev: FocusEvent) => void) => void;
+};

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

@@ -0,0 +1,34 @@
+import { ref as v, computed as u } from "vue";
+import { generateId as m } from "../utils/index.js";
+function g(n) {
+  const o = v(!1), r = u(n), i = n(), c = i.id || m(`nm-${i.prefix}`), f = u(() => typeof r.value.error == "string" ? r.value.error : ""), l = u(() => !!r.value.error);
+  function d(e) {
+    return u(() => [
+      e,
+      `${e}--${r.value.size}`,
+      {
+        [`${e}--focused`]: o.value,
+        [`${e}--disabled`]: r.value.disabled,
+        [`${e}--error`]: l.value
+      }
+    ]);
+  }
+  function a(e, t) {
+    o.value = !0, t("focus", e);
+  }
+  function s(e, t) {
+    o.value = !1, t("blur", e);
+  }
+  return {
+    isFocused: o,
+    fieldId: c,
+    errorMessage: f,
+    hasError: l,
+    baseClassList: d,
+    handleFocus: a,
+    handleBlur: s
+  };
+}
+export {
+  g as useFormField
+};

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

@@ -0,0 +1,18 @@
+import { LocaleMessages } from '../locales/types';
+
+export interface FormRule {
+    required?: boolean;
+    message?: string;
+    pattern?: RegExp;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    validator?: (value: unknown) => boolean | string;
+    /** @internal Reserved for future per-rule trigger support. Not yet implemented. */
+    trigger?: 'change' | 'blur' | 'input';
+}
+/**
+ * 验证单个字段值，返回错误消息（空字符串表示通过）
+ */
+export declare function validateFieldValue(value: unknown, rules: FormRule[], localeMessages?: Partial<LocaleMessages>): string;