@echolab-auto/echo-prodoc 0.1.0

package/vendor/@echolab/ui-frame/dist/components/ThemeProvider/ThemeProvider.d.ts

@@ -0,0 +1,56 @@
+import { Theme } from '../../composables/useTheme';
+
+export interface ThemeProviderProps {
+    /** Default theme mode */
+    defaultTheme?: Theme;
+    /** localStorage key for theme persistence */
+    storageKey?: string;
+    /** Whether to follow system preference when theme is 'auto' */
+    followSystem?: boolean;
+}
+declare function __VLS_template(): {
+    default?(_: {
+        theme: import('vue').Ref<Theme, Theme>;
+        currentTheme: import('vue').Ref<"light" | "dark", "light" | "dark">;
+        isDark: import('vue').Ref<boolean, boolean>;
+        setTheme: (theme: Theme) => void;
+        toggleTheme: () => void;
+    }): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ThemeProviderProps>, {
+    defaultTheme: string;
+    storageKey: string;
+    followSystem: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ThemeProviderProps>, {
+    defaultTheme: string;
+    storageKey: string;
+    followSystem: boolean;
+}>>> & Readonly<{}>, {
+    defaultTheme: Theme;
+    storageKey: string;
+    followSystem: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/vendor/@echolab/ui-frame/dist/components/ThemeProvider/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './ThemeProvider';
+export type { ThemeProviderProps } from './ThemeProvider';

package/vendor/@echolab/ui-frame/dist/components/ThemeProvider/index.js

@@ -0,0 +1,4 @@
+import { T as f } from "../../chunks/ThemeProvider-CCR_TjUs.js";
+export {
+  f as default
+};

package/vendor/@echolab/ui-frame/dist/components/index.d.ts

@@ -0,0 +1,92 @@
+export { default as NeumorphismButton } from './NeumorphismButton';
+export type { NeumorphismButtonProps, ButtonVariant, ButtonSize, ButtonShape, } from './NeumorphismButton';
+export { default as NeumorphismSwitch } from './NeumorphismSwitch';
+export type { NeumorphismSwitchProps } from './NeumorphismSwitch';
+export { default as NeumorphismCard } from './NeumorphismCard';
+export type { NeumorphismCardProps, CardVariant, CardDepth } from './NeumorphismCard';
+export { default as NeumorphismInput } from './NeumorphismInput';
+export type { NeumorphismInputProps, InputSize } from './NeumorphismInput';
+export { default as ThemeProvider } from './ThemeProvider';
+export type { ThemeProviderProps } from './ThemeProvider';
+export { default as NeumorphismCheckbox } from './NeumorphismCheckbox';
+export type { NeumorphismCheckboxProps } from './NeumorphismCheckbox';
+export { default as NeumorphismDatePicker } from './NeumorphismDatePicker';
+export type { NeumorphismDatePickerProps } from './NeumorphismDatePicker';
+export { default as NeumorphismSelect } from './NeumorphismSelect';
+export type { NeumorphismSelectProps, NeumorphismSelectOption } from './NeumorphismSelect';
+export { default as NeumorphismTextarea } from './NeumorphismTextarea';
+export type { NeumorphismTextareaProps } from './NeumorphismTextarea';
+export { NeumorphismFieldLabel, NeumorphismFieldError } from './NeumorphismField';
+export { default as NeumorphismModal } from './NeumorphismModal';
+export type { NeumorphismModalProps } from './NeumorphismModal';
+export { default as NeumorphismToastProvider } from './NeumorphismToast';
+export type { NeumorphismToastProviderProps, ToastOptions, ToastType, ToastPosition, ToastItem, } from './NeumorphismToast';
+export { default as NeumorphismTooltip } from './NeumorphismTooltip';
+export type { NeumorphismTooltipProps, TooltipPosition, TooltipTrigger } from './NeumorphismTooltip';
+export { default as NeumorphismAlert } from './NeumorphismAlert';
+export type { NeumorphismAlertProps, AlertType } from './NeumorphismAlert';
+export { default as NeumorphismPopover } from './NeumorphismPopover';
+export type { NeumorphismPopoverProps, PopoverPosition, PopoverTrigger } from './NeumorphismPopover';
+export { default as NeumorphismDropdown } from './NeumorphismDropdown';
+export type { NeumorphismDropdownProps, DropdownItem } from './NeumorphismDropdown';
+export { default as NeumorphismAutoComplete } from './NeumorphismAutoComplete';
+export type { NeumorphismAutoCompleteProps, NeumorphismAutoCompleteOption, } from './NeumorphismAutoComplete';
+export { default as NeumorphismEmpty } from './NeumorphismEmpty';
+export type { NeumorphismEmptyProps } from './NeumorphismEmpty';
+export { default as NeumorphismMenu } from './NeumorphismMenu';
+export type { NeumorphismMenuProps } from './NeumorphismMenu';
+export { default as NeumorphismNavMenu } from './NeumorphismNavMenu';
+export type { NeumorphismNavMenuProps } from './NeumorphismNavMenu';
+export { default as NeumorphismTabs } from './NeumorphismTabs';
+export type { NeumorphismTabsProps, TabItem } from './NeumorphismTabs';
+export { default as NeumorphismBreadcrumb } from './NeumorphismBreadcrumb';
+export type { NeumorphismBreadcrumbProps, BreadcrumbItem } from './NeumorphismBreadcrumb';
+export { default as NeumorphismPagination } from './NeumorphismPagination';
+export type { NeumorphismPaginationProps } from './NeumorphismPagination';
+export { default as NeumorphismAvatar } from './NeumorphismAvatar';
+export type { NeumorphismAvatarProps, AvatarSize } from './NeumorphismAvatar';
+export { default as NeumorphismBadge } from './NeumorphismBadge';
+export type { NeumorphismBadgeProps } from './NeumorphismBadge';
+export { default as NeumorphismTag } from './NeumorphismTag';
+export type { NeumorphismTagProps, TagVariant } from './NeumorphismTag';
+export { default as NeumorphismProgress } from './NeumorphismProgress';
+export type { NeumorphismProgressProps, ProgressVariant } from './NeumorphismProgress';
+export { default as NeumorphismSkeleton } from './NeumorphismSkeleton';
+export type { NeumorphismSkeletonProps } from './NeumorphismSkeleton';
+export { default as NeumorphismTable } from './NeumorphismTable';
+export type { NeumorphismTableProps, TableColumn } from './NeumorphismTable';
+export { default as NeumorphismVirtualList } from './NeumorphismVirtualList';
+export type { NeumorphismVirtualListProps } from './NeumorphismVirtualList';
+export { default as NeumorphismList } from './NeumorphismList';
+export type { NeumorphismListProps } from './NeumorphismList';
+export { default as NeumorphismDrawer } from './NeumorphismDrawer';
+export type { NeumorphismDrawerProps } from './NeumorphismDrawer';
+export { default as NeumorphismDivider } from './NeumorphismDivider';
+export type { NeumorphismDividerProps, DividerDirection, DividerAlign } from './NeumorphismDivider';
+export { default as NeumorphismCollapse } from './NeumorphismCollapse';
+export type { NeumorphismCollapseProps, CollapseItem } from './NeumorphismCollapse';
+export { default as NeumorphismContainer } from './NeumorphismContainer';
+export type { NeumorphismContainerProps } from './NeumorphismContainer';
+export { NeumorphismRow, NeumorphismCol } from './NeumorphismGrid';
+export type { NeumorphismRowProps, RowAlign, RowJustify } from './NeumorphismGrid';
+export type { NeumorphismColProps, ColSpan, ColOffset } from './NeumorphismGrid';
+export { default as NeumorphismLayout } from './NeumorphismLayout';
+export type { NeumorphismLayoutProps } from './NeumorphismLayout';
+export { default as NeumorphismThemeToggle } from './NeumorphismThemeToggle';
+export type { NeumorphismThemeToggleProps } from './NeumorphismThemeToggle';
+export { NeumorphismTree, NeumorphismTreeNode } from './NeumorphismTree';
+export type { NeumorphismTreeProps, NeumorphismTreeNodeProps, TreeNodeData, } from './NeumorphismTree';
+export { default as NeumorphismCanvas } from './NeumorphismCanvas';
+export type { NeumorphismCanvasProps } from './NeumorphismCanvas';
+export { NeumorphismRadio, NeumorphismRadioGroup } from './NeumorphismRadio';
+export type { NeumorphismRadioProps, NeumorphismRadioGroupProps } from './NeumorphismRadio';
+export { default as NeumorphismSlider } from './NeumorphismSlider';
+export type { NeumorphismSliderProps } from './NeumorphismSlider';
+export { default as NeumorphismInputNumber } from './NeumorphismInputNumber';
+export type { NeumorphismInputNumberProps } from './NeumorphismInputNumber';
+export { default as NeumorphismSteps } from './NeumorphismSteps';
+export type { NeumorphismStepsProps, StepItem, StepStatus } from './NeumorphismSteps';
+export { NeumorphismForm, NeumorphismFormItem } from './NeumorphismForm';
+export type { NeumorphismFormProps, NeumorphismFormItemProps, FormRule } from './NeumorphismForm';
+export { default as NeumorphismUpload } from './NeumorphismUpload';
+export type { NeumorphismUploadProps, UploadFile, UploadStatus } from './NeumorphismUpload';

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

@@ -0,0 +1,27 @@
+import { InjectionKey, Ref } from 'vue';
+import { FormRule } from './useFormValidation';
+
+export interface RadioGroupContext {
+    modelValue: Ref<unknown>;
+    name: Ref<string>;
+    disabled: Ref<boolean>;
+    size: Ref<string>;
+    setValue: (val: unknown) => void;
+}
+export interface FormContext {
+    model: Record<string, unknown>;
+    rules: Record<string, FormRule[]>;
+    errors: Record<string, string>;
+    labelWidth?: string;
+    size?: string;
+    validateField: (name: string) => boolean;
+    registerField: (name: string, validateFn: (value: unknown) => boolean) => void;
+    unregisterField: (name: string) => void;
+}
+export interface RowGutterContext {
+    x: Ref<number>;
+    y: Ref<number>;
+}
+export declare const RadioGroupKey: InjectionKey<RadioGroupContext>;
+export declare const FormKey: InjectionKey<FormContext>;
+export declare const RowGutterKey: InjectionKey<RowGutterContext>;

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

@@ -0,0 +1,6 @@
+const o = Symbol("nm-radio-group"), r = Symbol("nm-form"), m = Symbol("nm-row-gutter");
+export {
+  r as FormKey,
+  o as RadioGroupKey,
+  m as RowGutterKey
+};

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

@@ -0,0 +1,30 @@
+import { Ref } from 'vue';
+
+export type AlertType = 'info' | 'success' | 'warning' | 'error';
+export interface UseAlertOptions {
+    /**
+     * Auto-dismiss duration in milliseconds.
+     * 0 (default) means the alert must be closed manually.
+     */
+    duration?: number;
+}
+export interface UseAlertReturn {
+    /** Whether the alert is currently visible */
+    isVisible: Ref<boolean>;
+    /** Close the alert (triggers leave animation then hides) */
+    close: () => void;
+    /** Whether the alert is in its leave/dismiss animation phase */
+    leaving: Ref<boolean>;
+}
+/**
+ * Headless alert — encapsulates visibility state, auto-dismiss timer,
+ * and dismiss-animation lifecycle. Use with your own UI rendering.
+ *
+ * @example
+ * ```ts
+ * const { isVisible, close, leaving } = useAlert({ duration: 5000 })
+ * // When duration expires or close() is called, `leaving` flips to true,
+ * // the component runs its leave transition, then `isVisible` goes false.
+ * ```
+ */
+export declare function useAlert(opts?: UseAlertOptions): UseAlertReturn;

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

@@ -0,0 +1,25 @@
+import { ref as o, onBeforeUnmount as a } from "vue";
+function m(s = {}) {
+  const { duration: i = 0 } = s, t = o(!0), l = o(!1);
+  let u = null, e = null;
+  function n() {
+    u && (clearTimeout(u), u = null), e && (clearTimeout(e), e = null);
+  }
+  function r() {
+    l.value || !t.value || (n(), l.value = !0, e = setTimeout(() => {
+      t.value = !1, l.value = !1, e = null;
+    }, 250));
+  }
+  return i > 0 && (u = setTimeout(() => {
+    r();
+  }, i)), a(() => {
+    n();
+  }), {
+    isVisible: t,
+    close: r,
+    leaving: l
+  };
+}
+export {
+  m as useAlert
+};

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

@@ -0,0 +1,50 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface AutoCompleteOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface UseAutoCompleteOptions {
+    /** v-model value (the selected option's value) */
+    modelValue: Ref<string | number | undefined>;
+    /** Available options for local filtering */
+    options?: Ref<AutoCompleteOption[]>;
+    /** Async search function — when provided, filtering is server-side */
+    searchFn?: (query: string) => Promise<AutoCompleteOption[]>;
+    /** External loading ref (shared between composable and component) */
+    loading?: Ref<boolean>;
+    /** Debounce delay in ms for async search (default 300) */
+    debounceMs?: number;
+}
+export interface UseAutoCompleteReturn {
+    /** Current text in the input field */
+    inputValue: Ref<string>;
+    /** Whether the dropdown is open */
+    isOpen: Ref<boolean>;
+    /** Filtered options to display in the dropdown */
+    filteredOptions: ComputedRef<AutoCompleteOption[]>;
+    /** Index of the keyboard-navigated (active) option, -1 if none */
+    activeIndex: Ref<number>;
+    /** Generate an HTML string with matching portions wrapped in <mark> tags */
+    highlightMatch: (label: string) => string;
+    /** Select an option — sets modelValue, updates inputValue, closes dropdown */
+    selectOption: (option: AutoCompleteOption) => void;
+    /** Handle keyboard events for navigation */
+    handleKeydown: (event: KeyboardEvent) => void;
+    /** Handle input value changes */
+    handleInput: (value: string) => void;
+    /** Open the dropdown */
+    open: () => void;
+    /** Close the dropdown */
+    close: () => void;
+    /** Clean up internal timers (call in onBeforeUnmount) */
+    cleanupTimers: () => void;
+}
+/**
+ * Headless autocomplete — encapsulates filtering, keyboard navigation,
+ * async search with debounce, match highlighting, and open/close logic.
+ *
+ * Use with your own UI rendering (e.g., NeumorphismAutoComplete).
+ */
+export declare function useAutoComplete(opts: UseAutoCompleteOptions): UseAutoCompleteReturn;

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

@@ -0,0 +1,118 @@
+import { ref as f, computed as L, watch as C } from "vue";
+function m(d) {
+  return d.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function _(d) {
+  const { modelValue: k, options: g, searchFn: i, loading: n, debounceMs: D = 300 } = d, r = f(""), u = f(!1), t = f(-1), v = f([]), w = f(!1);
+  let s = null;
+  function T() {
+    s && (clearTimeout(s), s = null);
+  }
+  const p = L(() => i ? v.value : (g == null ? void 0 : g.value) ?? []), y = L(() => {
+    const e = r.value.trim().toLowerCase();
+    return i || !e ? p.value : p.value.filter((l) => l.label.toLowerCase().includes(e));
+  });
+  function x(e) {
+    const l = r.value.trim();
+    if (!l) return m(e);
+    const a = e.toLowerCase(), b = l.toLowerCase();
+    let h = "", c = 0;
+    for (; c < e.length; ) {
+      const o = a.indexOf(b, c);
+      if (o === -1) {
+        h += m(e.slice(c));
+        break;
+      }
+      h += m(e.slice(c, o)), h += '<mark class="nm-autocomplete__mark">' + m(e.slice(o, o + l.length)) + "</mark>", c = o + l.length;
+    }
+    return h;
+  }
+  function A(e) {
+    if (!i) return;
+    s && clearTimeout(s);
+    const l = e.trim();
+    if (!l) {
+      v.value = [], w.value = !1, n && (n.value = !1);
+      return;
+    }
+    w.value = !0, n && (n.value = !0), s = setTimeout(async () => {
+      try {
+        const a = await i(l);
+        v.value = a;
+      } catch {
+        v.value = [];
+      } finally {
+        w.value = !1, n && (n.value = !1);
+      }
+    }, D);
+  }
+  C(
+    k,
+    (e) => {
+      if (e === void 0 || e === "" || e === null)
+        return;
+      const a = p.value.find((b) => b.value === e);
+      a && a.label !== r.value && (r.value = a.label);
+    },
+    { flush: "sync" }
+  ), C(y, () => {
+    t.value = -1;
+  });
+  function q() {
+    u.value = !0;
+  }
+  function E() {
+    u.value = !1, t.value = -1;
+  }
+  function O(e) {
+    e.disabled || (k.value = e.value, r.value = e.label, u.value = !1, t.value = -1);
+  }
+  function I(e) {
+    r.value = e, t.value = -1, i && A(e), u.value || (u.value = !0);
+  }
+  function M(e) {
+    const l = y.value.filter((a) => !a.disabled);
+    switch (e.key) {
+      case "ArrowDown":
+        if (e.preventDefault(), !u.value) {
+          u.value = !0;
+          return;
+        }
+        if (l.length === 0) return;
+        t.value = t.value + 1 >= l.length ? 0 : t.value + 1;
+        break;
+      case "ArrowUp":
+        if (e.preventDefault(), !u.value) {
+          u.value = !0;
+          return;
+        }
+        if (l.length === 0) return;
+        t.value = t.value - 1 < 0 ? l.length - 1 : t.value - 1;
+        break;
+      case "Enter":
+        if (!u.value || l.length === 0) return;
+        e.preventDefault(), t.value >= 0 && t.value < l.length && O(l[t.value]);
+        break;
+      case "Escape":
+        e.preventDefault(), u.value = !1, t.value = -1;
+        break;
+    }
+  }
+  return {
+    inputValue: r,
+    isOpen: u,
+    filteredOptions: y,
+    activeIndex: t,
+    highlightMatch: x,
+    selectOption: O,
+    handleKeydown: M,
+    handleInput: I,
+    open: q,
+    close: E,
+    // Expose cleanup for lifecycle integration
+    cleanupTimers: T
+  };
+}
+export {
+  _ as useAutoComplete
+};

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

@@ -0,0 +1,17 @@
+export interface UseCheckableOptions {
+    prefix: 'checkbox' | 'radio';
+    isChecked: boolean;
+    isDisabled: boolean;
+    size: 'small' | 'medium' | 'large';
+    /** 额外类名（如 indeterminate） */
+    extraClasses?: Record<string, boolean>;
+}
+/**
+ * Checkbox/Radio 共享切换逻辑
+ */
+export declare function useCheckable(options: () => UseCheckableOptions): {
+    inputId: string;
+    classList: import('vue').ComputedRef<(string | {
+        [x: string]: boolean;
+    })[]>;
+};

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

@@ -0,0 +1,17 @@
+import { computed as a } from "vue";
+import { generateId as n } from "../utils/index.js";
+function c(i) {
+  const e = a(i), s = i(), t = n(`nm-${s.prefix}`), l = a(() => [
+    `nm-${e.value.prefix}`,
+    `nm-${e.value.prefix}--${e.value.size}`,
+    {
+      [`nm-${e.value.prefix}--checked`]: e.value.isChecked,
+      [`nm-${e.value.prefix}--disabled`]: e.value.isDisabled,
+      ...e.value.extraClasses
+    }
+  ]);
+  return { inputId: t, classList: l };
+}
+export {
+  c as useCheckable
+};

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

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+
+export interface CollapseItem {
+    key: string;
+    title: string;
+    disabled?: boolean;
+}
+export interface UseCollapseOptions {
+    /** v-model active keys */
+    modelValue: Ref<string[]>;
+    /** Collapse items */
+    items: Ref<CollapseItem[]>;
+    /** Whether accordion mode (only one panel open at a time) */
+    accordion?: Ref<boolean>;
+}
+export interface UseCollapseReturn {
+    /** Toggle a panel by key */
+    toggle: (key: string) => void;
+    /** Check if a panel is active */
+    isActive: (key: string) => boolean;
+}
+/**
+ * Headless collapse/accordion — encapsulates panel toggle logic.
+ * Use with your own UI rendering.
+ */
+export declare function useCollapse(opts: UseCollapseOptions): UseCollapseReturn;

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

@@ -0,0 +1,25 @@
+function f(s) {
+  const { modelValue: n, items: c } = s, l = s.accordion;
+  function o(e) {
+    const i = c.value.find((r) => r.key === e);
+    if (i != null && i.disabled) return;
+    const u = [...n.value], t = u.indexOf(e);
+    if (t >= 0)
+      u.splice(t, 1);
+    else {
+      if (l != null && l.value) {
+        n.value = [e];
+        return;
+      }
+      u.push(e);
+    }
+    n.value = u;
+  }
+  function a(e) {
+    return n.value.includes(e);
+  }
+  return { toggle: o, isActive: a };
+}
+export {
+  f as useCollapse
+};