@echolab-auto/echo-prodoc 0.1.0

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

@@ -0,0 +1,33 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface TabItem {
+    key: string;
+    label: string;
+    disabled?: boolean;
+    icon?: string;
+}
+export interface UseTabsOptions {
+    /** v-model active tab key */
+    modelValue: Ref<string>;
+    /** Tab items */
+    tabs: Ref<TabItem[]> | ComputedRef<TabItem[]>;
+    /** Tab position (determines arrow key direction) */
+    position?: Ref<'top' | 'left' | 'right' | 'bottom'>;
+}
+export interface UseTabsReturn {
+    /** Activate a tab by key */
+    activate: (key: string) => void;
+    /** Handle keyboard navigation */
+    handleKeydown: (event: KeyboardEvent, currentKey: string) => void;
+    /** Panel ID for ARIA */
+    panelId: ComputedRef<string>;
+    /** Tab list ID for ARIA */
+    tabListId: string;
+    /** ARIA orientation based on position */
+    orientation: ComputedRef<'horizontal' | 'vertical'>;
+}
+/**
+ * Headless tabs — encapsulates tab activation and keyboard navigation.
+ * Use with your own UI rendering.
+ */
+export declare function useTabs(opts: UseTabsOptions): UseTabsReturn;

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

@@ -0,0 +1,43 @@
+import { computed as p } from "vue";
+let y = 0;
+function v(a) {
+  const { modelValue: h, tabs: s } = a, i = a.position, u = `nm-tabs-${++y}`, b = p(() => `${u}-panel`), f = p(() => {
+    const e = i == null ? void 0 : i.value;
+    return e === "left" || e === "right" ? "vertical" : "horizontal";
+  });
+  function c(e) {
+    const r = s.value.find((t) => t.key === e);
+    r != null && r.disabled || (h.value = e);
+  }
+  function g(e, r) {
+    const t = s.value.filter((o) => !o.disabled);
+    if (t.length === 0) return;
+    const n = t.findIndex((o) => o.key === r);
+    let l;
+    if (f.value === "vertical")
+      if (e.key === "ArrowDown")
+        e.preventDefault(), l = n + 1 < t.length ? n + 1 : 0;
+      else if (e.key === "ArrowUp")
+        e.preventDefault(), l = n - 1 >= 0 ? n - 1 : t.length - 1;
+      else
+        return;
+    else if (e.key === "ArrowRight")
+      e.preventDefault(), l = n + 1 < t.length ? n + 1 : 0;
+    else if (e.key === "ArrowLeft")
+      e.preventDefault(), l = n - 1 >= 0 ? n - 1 : t.length - 1;
+    else
+      return;
+    const d = t[l];
+    d && c(d.key);
+  }
+  return {
+    activate: c,
+    handleKeydown: g,
+    panelId: b,
+    tabListId: u,
+    orientation: f
+  };
+}
+export {
+  v as useTabs
+};

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

@@ -0,0 +1,40 @@
+import { Ref } from 'vue';
+
+export type Theme = 'light' | 'dark' | 'auto';
+export interface ThemeOptions {
+    defaultTheme?: Theme;
+    storageKey?: string;
+    followSystem?: boolean;
+}
+export interface ThemeContext {
+    theme: Ref<Theme>;
+    currentTheme: Ref<'light' | 'dark'>;
+    isDark: Ref<boolean>;
+    setTheme: (theme: Theme) => void;
+    toggleTheme: () => void;
+    dispose: () => void;
+}
+/**
+ * Create theme state for a component tree.
+ * The returned context is independent — each call gets its own state
+ * and event listeners, safe for SSR and concurrent usage.
+ */
+export declare function createTheme(options?: ThemeOptions): ThemeContext;
+/**
+ * Provide theme context to child components.
+ *
+ * Accepts a plain object or a reactive ref/computed. When a ref is passed,
+ * `defaultTheme` changes are propagated automatically at runtime.
+ *
+ * Note: `storageKey` and `followSystem` are only read at initialization.
+ *       Changing them at runtime requires remounting the provider.
+ */
+export declare function provideTheme(options?: ThemeOptions | Ref<ThemeOptions>): ThemeContext;
+/**
+ * Inject theme context from parent.
+ *
+ * If no provider is found, creates an independent fallback context
+ * that is disposed when the calling component unmounts.
+ * This avoids module-level shared state that leaks across SSR requests.
+ */
+export declare function useTheme(): ThemeContext;

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

@@ -0,0 +1,81 @@
+import { inject as w, onBeforeUnmount as l, unref as y, provide as k, isRef as S, watch as h, ref as E, computed as m } from "vue";
+const p = Symbol("neumorphism-theme"), b = "nm-theme-preference";
+function s() {
+  return typeof window > "u" ? "light" : window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function x(e) {
+  if (typeof window > "u") return null;
+  try {
+    return localStorage.getItem(e);
+  } catch {
+    return null;
+  }
+}
+function A(e, t) {
+  if (!(typeof window > "u"))
+    try {
+      localStorage.setItem(t, e);
+    } catch {
+    }
+}
+function f(e) {
+  if (typeof document > "u") return;
+  const t = document.documentElement;
+  e ? t.setAttribute("data-theme", "dark") : t.removeAttribute("data-theme");
+}
+function g(e = {}) {
+  const { defaultTheme: t = "auto", storageKey: o = b, followSystem: T = !0 } = e, v = x(o), r = E(v || t), c = m(() => r.value === "auto" ? s() : r.value), a = m(() => c.value === "dark");
+  h(
+    a,
+    (n) => {
+      f(n);
+    },
+    { immediate: !0 }
+  );
+  let u, i;
+  T && typeof window < "u" && (u = window.matchMedia("(prefers-color-scheme: dark)"), i = () => {
+    r.value === "auto" && f(s() === "dark");
+  }, u.addEventListener("change", i));
+  const d = (n) => {
+    r.value = n, A(n, o);
+  };
+  return {
+    theme: r,
+    currentTheme: c,
+    isDark: a,
+    setTheme: d,
+    toggleTheme: () => {
+      const n = a.value ? "light" : "dark";
+      d(n);
+    },
+    dispose: () => {
+      u && i && u.removeEventListener("change", i);
+    }
+  };
+}
+function L(e = {}) {
+  const t = g(y(e));
+  return k(p, t), S(e) && h(
+    () => e.value.defaultTheme,
+    (o) => {
+      o !== void 0 && t.setTheme(o);
+    }
+  ), l(() => {
+    t.dispose();
+  }), t;
+}
+function M() {
+  const e = w(p, null);
+  if (!e) {
+    const t = g();
+    return l(() => {
+      t.dispose();
+    }), t;
+  }
+  return e;
+}
+export {
+  g as createTheme,
+  L as provideTheme,
+  M as useTheme
+};

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

@@ -0,0 +1,44 @@
+import { Ref } from 'vue';
+
+export type ToastType = 'info' | 'success' | 'warning' | 'error';
+export type ToastPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center';
+export interface ToastItem {
+    id: string;
+    message: string;
+    type: ToastType;
+    duration: number;
+    closable: boolean;
+    timestamp: number;
+    leaving: boolean;
+}
+export interface ToastOptions {
+    message: string;
+    type?: ToastType;
+    duration?: number;
+    closable?: boolean;
+}
+export interface UseToastOptions {
+    /** Maximum number of toasts visible at once */
+    maxCount?: number;
+}
+export interface UseToastReturn {
+    /** Current toast items */
+    toasts: Ref<ToastItem[]>;
+    /** Add a toast notification */
+    addToast: (options: ToastOptions) => string;
+    /** Remove a toast by ID */
+    removeToast: (id: string) => void;
+    /** Clear all toasts */
+    clearAll: () => void;
+}
+/**
+ * Headless toast — encapsulates toast queue management, auto-dismiss
+ * timers, and remove animations. Use with your own UI rendering.
+ *
+ * @example
+ * ```ts
+ * const { toasts, addToast, removeToast } = useToast({ maxCount: 5 })
+ * addToast({ message: 'Saved!', type: 'success', duration: 3000 })
+ * ```
+ */
+export declare function useToast(opts?: UseToastOptions): UseToastReturn;

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

@@ -0,0 +1,57 @@
+import { ref as g, onBeforeUnmount as T } from "vue";
+function d() {
+  return `nm-toast-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function h(s = {}) {
+  const { maxCount: c = 5 } = s, a = g([]), t = /* @__PURE__ */ new Map();
+  let r = !1;
+  function n(e) {
+    const l = t.get(e);
+    l && (clearTimeout(l), t.delete(e));
+  }
+  function f(e) {
+    const l = d(), o = {
+      id: l,
+      message: e.message,
+      type: e.type || "info",
+      duration: e.duration ?? 3e3,
+      closable: e.closable ?? !0,
+      timestamp: Date.now(),
+      leaving: !1
+    };
+    if (a.value = [...a.value.slice(Math.max(0, a.value.length - (c - 1))), o], r) {
+      const u = t.get("__clearAll");
+      u && (clearTimeout(u), t.delete("__clearAll")), r = !1, a.value = a.value.filter((v) => !v.leaving);
+    }
+    return o.duration > 0 && (n(l), t.set(
+      l,
+      setTimeout(() => i(l), o.duration)
+    )), l;
+  }
+  function i(e) {
+    n(e);
+    const l = a.value.find((o) => o.id === e);
+    l && (l.leaving = !0), t.set(
+      e,
+      setTimeout(() => {
+        a.value = a.value.filter((o) => o.id !== e), t.delete(e);
+      }, 250)
+    );
+  }
+  function m() {
+    t.forEach((e) => clearTimeout(e)), t.clear(), r = !0, a.value.forEach((e) => {
+      e.leaving = !0;
+    }), t.set(
+      "__clearAll",
+      setTimeout(() => {
+        a.value = [], t.delete("__clearAll"), r = !1;
+      }, 250)
+    );
+  }
+  return T(() => {
+    t.forEach((e) => clearTimeout(e)), t.clear();
+  }), { toasts: a, addToast: f, removeToast: i, clearAll: m };
+}
+export {
+  h as useToast
+};

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

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+
+export type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+export type TooltipTrigger = 'hover' | 'click' | 'focus';
+export interface UseTooltipOptions {
+    /** Whether the tooltip is disabled */
+    disabled?: Ref<boolean>;
+    /** Delay before showing (ms) */
+    delay?: number;
+    /** Trigger mode */
+    trigger?: Ref<TooltipTrigger>;
+}
+export interface UseTooltipReturn {
+    /** Whether the tooltip is visible */
+    isVisible: Ref<boolean>;
+    /** Show the tooltip */
+    show: () => void;
+    /** Hide the tooltip */
+    hide: () => void;
+    /** Toggle visibility (for click trigger) */
+    toggle: () => void;
+    /** Handle keydown (Escape to close) */
+    handleKeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Headless tooltip — encapsulates show/hide with delay, toggle for
+ * click trigger, and keyboard dismissal. Use with your own UI rendering.
+ */
+export declare function useTooltip(opts?: UseTooltipOptions): UseTooltipReturn;

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

@@ -0,0 +1,27 @@
+import { ref as m, onBeforeUnmount as s } from "vue";
+function v(t = {}) {
+  const { disabled: u } = t, f = t.delay ?? 150, n = m(!1);
+  let e = null, l = null;
+  function i() {
+    u != null && u.value || (l && (clearTimeout(l), l = null), e = setTimeout(() => {
+      n.value = !0;
+    }, f));
+  }
+  function o() {
+    e && (clearTimeout(e), e = null), l = setTimeout(() => {
+      n.value = !1;
+    }, 100);
+  }
+  function r() {
+    u != null && u.value || (n.value ? o() : i());
+  }
+  function a(c) {
+    c.key === "Escape" && (n.value = !1);
+  }
+  return s(() => {
+    e && (clearTimeout(e), e = null), l && (clearTimeout(l), l = null);
+  }), { isVisible: n, show: i, hide: o, toggle: r, handleKeydown: a };
+}
+export {
+  v as useTooltip
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Detect touch-capable devices and mobile viewport
+ */
+export declare function useTouchDevice(): {
+    isTouch: import('vue').Ref<boolean, boolean>;
+    isMobile: import('vue').Ref<boolean, boolean>;
+};

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

@@ -0,0 +1,25 @@
+import { ref as u, onMounted as d, onBeforeUnmount as l } from "vue";
+function v() {
+  const t = u(!1), o = u(!1);
+  let i;
+  function r() {
+    o.value = window.innerWidth < 768;
+  }
+  function a() {
+    clearTimeout(i), i = setTimeout(r, 100);
+  }
+  function s() {
+    t.value = !0;
+  }
+  let e, n;
+  return d(() => {
+    window.matchMedia && (e = window.matchMedia("(pointer: coarse)"), t.value = e.matches, n = (c) => {
+      t.value = c.matches;
+    }, e.addEventListener("change", n)), window.addEventListener("touchstart", s, { once: !0, passive: !0 }), r(), window.addEventListener("resize", a, { passive: !0 });
+  }), l(() => {
+    e && n && e.removeEventListener("change", n), window.removeEventListener("touchstart", s), window.removeEventListener("resize", a), clearTimeout(i);
+  }), { isTouch: t, isMobile: o };
+}
+export {
+  v as useTouchDevice
+};

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

@@ -0,0 +1,50 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface TreeNodeData {
+    key: string;
+    label: string;
+    children?: TreeNodeData[];
+    disabled?: boolean;
+    [k: string]: unknown;
+}
+export interface UseTreeOptions {
+    /** Tree data */
+    data: Ref<TreeNodeData[]> | ComputedRef<TreeNodeData[]>;
+    /** v-model selected keys */
+    selectedKeys?: Ref<string[]>;
+    /** v-model expanded keys */
+    expandedKeys?: Ref<string[]>;
+    /** Whether multiple selection is allowed */
+    multiple?: Ref<boolean>;
+}
+export interface UseTreeReturn {
+    /** Local expanded keys */
+    localExpandedKeys: Ref<string[]>;
+    /** Local selected keys */
+    localSelectedKeys: Ref<string[]>;
+    /** All node keys in the tree */
+    allKeys: ComputedRef<string[]>;
+    /** Search text for filtering */
+    searchText: Ref<string>;
+    /** Currently focused key for keyboard navigation */
+    focusedKey: Ref<string | null>;
+    /** Toggle expand/collapse of a node */
+    toggleExpand: (key: string) => void;
+    /** Select a node */
+    select: (key: string) => void;
+    /** Find a node by key */
+    findNode: (nodes: TreeNodeData[], key: string) => TreeNodeData | null;
+    /** Expand all nodes */
+    expandAll: () => void;
+    /** Collapse all nodes */
+    collapseAll: () => void;
+    /** Handle search input — auto-expands matching nodes */
+    onSearchInput: (value: string) => void;
+    /** Handle keyboard navigation events */
+    handleKeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Headless tree — encapsulates expand/collapse, selection, search, and
+ * node lookup without any rendering. Use with your own UI.
+ */
+export declare function useTree(opts: UseTreeOptions): UseTreeReturn;

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

@@ -0,0 +1,219 @@
+import { ref as y, computed as m, watch as A, nextTick as E } from "vue";
+function M(c, a) {
+  if (c.length !== a.length) return !1;
+  for (let r = 0; r < c.length; r++)
+    if (c[r] !== a[r]) return !1;
+  return !0;
+}
+function G(c) {
+  const a = [];
+  function r(l) {
+    var u;
+    for (const o of l)
+      a.push(o.key), (u = o.children) != null && u.length && r(o.children);
+  }
+  return r(c), a;
+}
+function J(c, a) {
+  const r = [], l = a.toLowerCase();
+  function u(o) {
+    var s;
+    let t = !1;
+    for (const f of o) {
+      const k = f.label.toLowerCase().includes(l);
+      let h = !1;
+      (s = f.children) != null && s.length && (h = u(f.children)), (k || h) && (r.push(f.key), t = !0);
+    }
+    return t;
+  }
+  return u(c), r;
+}
+function p(c, a) {
+  var r;
+  for (const l of c) {
+    if (l.key === a) return l;
+    if ((r = l.children) != null && r.length) {
+      const u = p(l.children, a);
+      if (u) return u;
+    }
+  }
+  return null;
+}
+function I(c, a, r = []) {
+  var l;
+  for (const u of c)
+    r.push(u), (l = u.children) != null && l.length && a.includes(u.key) && I(u.children, a, r);
+  return r;
+}
+function P(c, a = null, r = /* @__PURE__ */ new Map()) {
+  var l;
+  for (const u of c)
+    r.set(u.key, a), (l = u.children) != null && l.length && P(u.children, u.key, r);
+  return r;
+}
+function X(c) {
+  var D, L;
+  const { data: a } = c, r = c.multiple ?? y(!1), l = y([...((D = c.expandedKeys) == null ? void 0 : D.value) ?? []]), u = y([...((L = c.selectedKeys) == null ? void 0 : L.value) ?? []]), o = y(""), t = y(null);
+  let s = !1;
+  function f(e, n) {
+    e && A(
+      () => e.value,
+      (i) => {
+        if (s) return;
+        const d = [...i];
+        M(n.value, d) || (s = !0, n.value = d, E(() => {
+          s = !1;
+        }));
+      },
+      { immediate: !0, deep: !0 }
+    );
+  }
+  function k(e, n) {
+    n && A(
+      () => e.value,
+      (i) => {
+        if (s) return;
+        const d = [...i];
+        M(n.value, d) || (s = !0, n.value = d, E(() => {
+          s = !1;
+        }));
+      },
+      { deep: !0 }
+    );
+  }
+  f(c.selectedKeys, u), f(c.expandedKeys, l), k(u, c.selectedKeys), k(l, c.expandedKeys);
+  const h = m(() => G(a.value)), v = m(() => I(a.value, l.value)), C = m(() => P(a.value));
+  function g(e) {
+    const n = l.value.indexOf(e);
+    n === -1 ? l.value.push(e) : l.value.splice(n, 1);
+  }
+  function K(e) {
+    if (r.value) {
+      const n = u.value.indexOf(e);
+      n === -1 ? u.value.push(e) : u.value.splice(n, 1);
+    } else
+      u.value = [e];
+  }
+  function F() {
+    l.value = [...h.value];
+  }
+  function N() {
+    l.value = [];
+  }
+  function O(e) {
+    if (o.value = e, e.trim()) {
+      const n = J(a.value, e);
+      l.value = [.../* @__PURE__ */ new Set([...l.value, ...n])];
+    }
+  }
+  let x = "", w = null;
+  function S(e) {
+    x += e.toLowerCase(), w && clearTimeout(w), w = setTimeout(() => {
+      x = "";
+    }, 500);
+    const n = v.value, i = t.value ? n.findIndex((b) => b.key === t.value) + 1 : 0, T = [...n.slice(i), ...n.slice(0, i)].find((b) => b.label.toLowerCase().startsWith(x));
+    T && (t.value = T.key);
+  }
+  function q() {
+    const e = v.value;
+    if (!e.length) return;
+    if (!t.value) {
+      t.value = e[0].key;
+      return;
+    }
+    const n = e.findIndex((i) => i.key === t.value);
+    n >= 0 && n < e.length - 1 && (t.value = e[n + 1].key);
+  }
+  function B() {
+    const e = v.value;
+    if (!e.length) return;
+    if (!t.value) {
+      t.value = e[e.length - 1].key;
+      return;
+    }
+    const n = e.findIndex((i) => i.key === t.value);
+    n > 0 && (t.value = e[n - 1].key);
+  }
+  function H() {
+    const e = v.value;
+    e.length && (t.value = e[0].key);
+  }
+  function R() {
+    const e = v.value;
+    e.length && (t.value = e[e.length - 1].key);
+  }
+  function U() {
+    if (!t.value) return;
+    const e = C.value.get(t.value);
+    e && (t.value = e);
+  }
+  function V() {
+    var n;
+    if (!t.value) return;
+    const e = p(a.value, t.value);
+    (n = e == null ? void 0 : e.children) != null && n.length && (l.value.includes(e.key) || g(e.key), t.value = e.children[0].key);
+  }
+  function W() {
+    var n;
+    if (!t.value) return;
+    const e = p(a.value, t.value);
+    (n = e == null ? void 0 : e.children) != null && n.length && l.value.includes(e.key) ? g(e.key) : U();
+  }
+  function j() {
+    var n;
+    if (!t.value) return;
+    const e = p(a.value, t.value);
+    (n = e == null ? void 0 : e.children) != null && n.length && g(e.key);
+  }
+  function z(e) {
+    const n = e.key;
+    if (n.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+      S(n), e.preventDefault();
+      return;
+    }
+    switch (n) {
+      case "ArrowDown":
+        q(), e.preventDefault();
+        break;
+      case "ArrowUp":
+        B(), e.preventDefault();
+        break;
+      case "ArrowRight":
+        V(), e.preventDefault();
+        break;
+      case "ArrowLeft":
+        W(), e.preventDefault();
+        break;
+      case "Enter":
+      case " ":
+        t.value && K(t.value), e.preventDefault();
+        break;
+      case "Home":
+        H(), e.preventDefault();
+        break;
+      case "End":
+        R(), e.preventDefault();
+        break;
+      case "*":
+        j(), e.preventDefault();
+        break;
+    }
+  }
+  return {
+    localExpandedKeys: l,
+    localSelectedKeys: u,
+    allKeys: h,
+    searchText: o,
+    focusedKey: t,
+    toggleExpand: g,
+    select: K,
+    findNode: p,
+    expandAll: F,
+    collapseAll: N,
+    onSearchInput: O,
+    handleKeydown: z
+  };
+}
+export {
+  X as useTree
+};