@echolab-auto/echo-prodoc 0.1.0

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

@@ -0,0 +1,81 @@
+import { Ref, ComputedRef } from 'vue';
+
+export type UploadStatus = 'pending' | 'uploading' | 'done' | 'error';
+export interface UploadFile {
+    /** Unique identifier */
+    id: string;
+    /** Original file name */
+    name: string;
+    /** File size in bytes */
+    size: number;
+    /** MIME type */
+    type: string;
+    /** Upload lifecycle status */
+    status: UploadStatus;
+    /** Upload progress (0–100) */
+    progress: number;
+    /** ObjectURL for image preview (cleaned up on remove) */
+    url?: string;
+    /** Error message if status === 'error' */
+    error?: string;
+    /** Raw File object reference */
+    raw?: File;
+}
+export interface UseUploadOptions {
+    /** Accepted MIME types / extensions, e.g. "image/*,.pdf" */
+    accept?: Ref<string | undefined> | ComputedRef<string | undefined>;
+    /** Maximum file size in bytes */
+    maxSize?: Ref<number | undefined> | ComputedRef<number | undefined>;
+    /** Maximum number of files allowed */
+    maxCount?: Ref<number | undefined> | ComputedRef<number | undefined>;
+    /** Whether multiple files can be selected */
+    multiple?: Ref<boolean> | ComputedRef<boolean>;
+    /** Automatically start upload after file selection */
+    autoUpload?: Ref<boolean> | ComputedRef<boolean>;
+    /** Callback when file count exceeds maxCount */
+    onExceed?: (excessCount: number) => void;
+    /** Callback when file size exceeds maxSize */
+    onSizeExceed?: (file: File) => void;
+    /** Callback when file type is not accepted */
+    onTypeError?: (file: File) => void;
+    /** Custom upload function — receives file, returns a promise resolving to progress (0–100) or void */
+    uploadFn?: (file: UploadFile) => Promise<void>;
+}
+export interface UseUploadReturn {
+    /** Current file list */
+    files: Ref<UploadFile[]>;
+    /** Whether a drag operation is hovering over the drop zone */
+    dragOver: Ref<boolean>;
+    /** Add files to the list (validates first) */
+    addFiles: (fileList: FileList | File[]) => void;
+    /** Remove a single file by id — cleans up ObjectURL */
+    removeFile: (id: string) => void;
+    /** Clear all files — cleans up all ObjectURLs */
+    clearFiles: () => void;
+    /** Manually trigger upload for pending files */
+    upload: () => Promise<void>;
+    /** Hidden file input element ref */
+    fileInputRef: Ref<HTMLInputElement | null>;
+    /** Set dragOver to true on dragover/enter */
+    handleDrag: (event: DragEvent) => void;
+    /** Reset dragOver counter on dragleave */
+    handleDragLeave: (event: DragEvent) => void;
+    /** Add files from drop event, reset dragOver */
+    handleDrop: (event: DragEvent) => void;
+    /** Open file picker dialog */
+    handleFileInput: (event: Event) => void;
+}
+/**
+ * Headless upload — encapsulates file selection, validation, drag-and-drop
+ * tracking, upload progress simulation, and ObjectURL lifecycle management.
+ * Use with your own UI rendering.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { useUpload } from '@echolab/ui-frame'
+ * const { files, dragOver, fileInputRef, addFiles, removeFile, clearFiles, upload, handleDrag, handleDrop, handleFileInput } = useUpload({})
+ * </script>
+ * ```
+ */
+export declare function useUpload(opts?: UseUploadOptions): UseUploadReturn;

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

@@ -0,0 +1,169 @@
+import { ref as w, onBeforeUnmount as B } from "vue";
+import { generateId as x } from "../utils/index.js";
+function $(z = {}) {
+  const {
+    accept: i,
+    maxSize: c,
+    maxCount: p,
+    multiple: d,
+    autoUpload: v,
+    onExceed: g,
+    onSizeExceed: m,
+    onTypeError: h,
+    uploadFn: F
+  } = z, n = w([]), f = w(!1), D = w(null);
+  let l = 0;
+  function U(e, t) {
+    return t.split(",").map((r) => r.trim()).filter(Boolean).some((r) => {
+      if (r.endsWith("/*")) {
+        const o = r.slice(0, -1);
+        return e.startsWith(o);
+      }
+      return r.startsWith(".") ? e.endsWith(r) || e === r.toLowerCase() : e === r;
+    });
+  }
+  function P(e) {
+    try {
+      return URL.createObjectURL(e);
+    } catch {
+      return "";
+    }
+  }
+  function y(e) {
+    if (e)
+      try {
+        URL.revokeObjectURL(e);
+      } catch {
+      }
+  }
+  function M(e) {
+    var t;
+    if (c != null && c.value && e.size > c.value)
+      return m == null || m(e), "sizeExceed";
+    if (i != null && i.value && e.type && !U(e.type, i.value)) {
+      const a = `.${(t = e.name.split(".").pop()) == null ? void 0 : t.toLowerCase()}`;
+      if (!U(a, i.value))
+        return h == null || h(e), "typeError";
+    }
+    return null;
+  }
+  function O(e) {
+    const t = e.type.startsWith("image/") ? P(e) : void 0;
+    return {
+      id: x("upload_"),
+      name: e.name,
+      size: e.size,
+      type: e.type,
+      status: "pending",
+      progress: 0,
+      url: t,
+      raw: e
+    };
+  }
+  function L(e) {
+    const t = Array.from(e), a = (d == null ? void 0 : d.value) ?? !1, r = p == null ? void 0 : p.value;
+    if (r !== void 0) {
+      const s = n.value.length + t.length;
+      if (s > r) {
+        g == null || g(s - r);
+        const u = r - n.value.length;
+        if (u <= 0) return;
+        t.splice(u);
+      }
+    }
+    a || I();
+    const o = [];
+    for (const s of t) {
+      const u = M(s);
+      if (u) {
+        const k = {
+          id: x("upload_"),
+          name: s.name,
+          size: s.size,
+          type: s.type,
+          status: "error",
+          progress: 0,
+          error: u === "sizeExceed" ? "sizeExceed" : "typeError"
+        };
+        o.push(k);
+      } else
+        o.push(O(s));
+    }
+    n.value = [...n.value, ...o], v != null && v.value && o.some((s) => s.status === "pending") && R();
+  }
+  function W(e) {
+    const t = n.value.findIndex((r) => r.id === e);
+    if (t === -1) return;
+    const a = n.value[t];
+    y(a.url), n.value = n.value.filter((r) => r.id !== e);
+  }
+  function I() {
+    for (const e of n.value)
+      y(e.url);
+    n.value = [];
+  }
+  async function R() {
+    const e = n.value.filter((t) => t.status === "pending");
+    for (const t of e)
+      t.status = "uploading", t.progress = 0;
+    if (F) {
+      await Promise.allSettled(
+        e.map(async (t) => {
+          try {
+            await F(t), t.status = "done", t.progress = 100;
+          } catch (a) {
+            t.status = "error", t.error = a instanceof Error ? a.message : "uploadFail";
+          }
+        })
+      );
+      return;
+    }
+    await Promise.allSettled(
+      e.map(
+        (t) => new Promise((a) => {
+          const r = setInterval(() => {
+            if (t.status !== "uploading") {
+              clearInterval(r);
+              return;
+            }
+            t.progress = Math.min(100, t.progress + 15 + Math.random() * 10), t.progress >= 100 && (clearInterval(r), t.status = "done", a());
+          }, 300);
+        })
+      )
+    );
+  }
+  function b(e) {
+    e.preventDefault(), e.stopPropagation(), (e.type === "dragover" || e.type === "dragenter") && (l++, f.value = !0);
+  }
+  function j(e) {
+    e.preventDefault(), e.stopPropagation(), l = Math.max(0, l - 1), l === 0 && (f.value = !1);
+  }
+  function A(e) {
+    e.preventDefault(), e.stopPropagation(), f.value = !1, l = 0;
+    const t = e.dataTransfer;
+    t != null && t.files && t.files.length > 0 && L(t.files);
+  }
+  function E(e) {
+    const t = e.target;
+    t != null && t.files && t.files.length > 0 && (L(t.files), t.value = "");
+  }
+  return B(() => {
+    for (const e of n.value)
+      y(e.url);
+  }), {
+    files: n,
+    dragOver: f,
+    addFiles: L,
+    removeFile: W,
+    clearFiles: I,
+    upload: R,
+    fileInputRef: D,
+    handleDrag: b,
+    handleDragLeave: j,
+    handleDrop: A,
+    handleFileInput: E
+  };
+}
+export {
+  $ as useUpload
+};

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

@@ -0,0 +1,59 @@
+import { Ref, ComputedRef } from 'vue';
+
+export interface UseVirtualListOptions {
+    /**
+     * The full data array to virtualize.
+     * The composable reads `items.value.length` to compute total height.
+     */
+    items: Ref<any[]>;
+    /**
+     * Item height in pixels.
+     * - `number` — every item has the same fixed height.
+     * - `(index: number) => number` — dynamic per-item height function.
+     *   When using dynamic heights the composable caches measured values.
+     */
+    itemHeight: Ref<number | ((index: number) => number)> | number | ((index: number) => number);
+    /**
+     * Number of extra items to render above and below the visible viewport.
+     * Higher values produce smoother scrolling at the cost of more DOM nodes.
+     * @default 5
+     */
+    overscan?: Ref<number> | number;
+}
+export interface UseVirtualListReturn {
+    /**
+     * Template ref to attach to the scrollable container element.
+     * The container must have overflow-y: auto (or scroll).
+     */
+    containerRef: Ref<HTMLElement | null>;
+    /** The currently visible slice of `items` — iterate this in the template. */
+    visibleItems: ComputedRef<any[]>;
+    /** Total height of the virtual spacer (all items combined), in px. */
+    totalHeight: Ref<number>;
+    /** Vertical translate offset for the visible-items wrapper, in px. */
+    offsetY: Ref<number>;
+    /** Start index of the visible range (inclusive). */
+    startIndex: Ref<number>;
+    /** End index of the visible range (exclusive). */
+    endIndex: Ref<number>;
+    /**
+     * Scroll to a specific item by index, optionally aligned to the
+     * top (default) or center of the viewport.
+     */
+    scrollTo: (index: number, align?: 'top' | 'center') => void;
+    /**
+     * Attach to the container's @scroll event.
+     * The composable recalculates the visible window on each call.
+     */
+    handleScroll: () => void;
+}
+/**
+ * Headless virtual list composable.
+ *
+ * Encapsulates scroll-driven window calculation, viewport measurement
+ * via ResizeObserver, fixed and dynamic item-height support, overscan,
+ * and imperative scroll-to-item. Use with your own UI rendering — mount
+ * `containerRef` on the scrollable wrapper and wire `handleScroll` to its
+ * `@scroll` event.
+ */
+export declare function useVirtualList(opts: UseVirtualListOptions): UseVirtualListReturn;

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

@@ -0,0 +1,107 @@
+import { computed as T, ref as s, onMounted as U, onBeforeUnmount as Y, watch as V } from "vue";
+function k(w) {
+  const { items: i } = w, x = T(() => {
+    const e = w.overscan;
+    return e == null ? 5 : typeof e == "number" ? e : e.value ?? 5;
+  }), B = T(() => {
+    const e = w.itemHeight;
+    let n;
+    if (typeof e == "number")
+      n = () => e;
+    else if (typeof e == "function")
+      n = e;
+    else {
+      const t = e.value;
+      n = typeof t == "number" ? () => t : t;
+    }
+    return n;
+  }), h = s(null), c = s(0);
+  let a = null;
+  function R() {
+    a && (a.disconnect(), a = null);
+  }
+  function C() {
+    R();
+    const e = h.value;
+    !e || typeof ResizeObserver > "u" || (c.value = e.clientHeight, a = new ResizeObserver(([n]) => {
+      const t = n.contentRect.height;
+      t !== c.value && (c.value = t);
+    }), a.observe(e));
+  }
+  U(() => {
+    C();
+  }), Y(() => {
+    R();
+  });
+  const M = s(0);
+  function E() {
+    const e = h.value;
+    e && (M.value = e.scrollTop);
+  }
+  let H = /* @__PURE__ */ new Map();
+  function z(e) {
+    const n = B.value, t = H.get(e);
+    if (t !== void 0) return t;
+    const o = n(e);
+    return H.set(e, t !== void 0 ? t : o), o;
+  }
+  function I() {
+    const e = i.value.length, n = [0];
+    for (let t = 0; t < e; t++) {
+      const o = n[t];
+      n.push(o + z(t));
+    }
+    return n;
+  }
+  const y = s(0), m = s(0), d = s(0), O = s(0);
+  function S() {
+    const e = i.value.length;
+    if (e === 0) {
+      y.value = 0, m.value = 0, d.value = 0, O.value = 0;
+      return;
+    }
+    const n = c.value;
+    if (n === 0) return;
+    const t = x.value, o = M.value, l = I();
+    y.value = l[e];
+    let p = 0, r = e - 1, g = 0;
+    for (; p <= r; ) {
+      const b = p + r >>> 1;
+      l[b + 1] <= o ? p = b + 1 : (g = b, r = b - 1);
+    }
+    const f = Math.max(0, g - t), v = o + n;
+    let u = f;
+    for (; u < e && l[u + 1] < v; )
+      u++;
+    u = Math.min(e, u + 1 + t), m.value = f, d.value = u, O.value = l[f];
+  }
+  V(
+    () => i.value,
+    () => {
+      H = /* @__PURE__ */ new Map(), S();
+    }
+  ), V([M, c, x], () => S(), { deep: !1, immediate: !1 });
+  const F = T(() => i.value.slice(m.value, d.value));
+  function L(e, n = "top") {
+    const t = h.value;
+    if (!t) return;
+    const o = i.value.length;
+    if (o === 0) return;
+    const l = Math.max(0, Math.min(o - 1, e)), r = I()[l], g = z(l), f = c.value;
+    let v;
+    n === "center" ? v = r - (f - g) / 2 : v = r, t.scrollTo({ top: Math.max(0, v), behavior: "smooth" });
+  }
+  return {
+    containerRef: h,
+    visibleItems: F,
+    totalHeight: y,
+    offsetY: O,
+    startIndex: m,
+    endIndex: d,
+    scrollTo: L,
+    handleScroll: E
+  };
+}
+export {
+  k as useVirtualList
+};

package/vendor/@echolab/ui-frame/dist/doc/DocEditor.d.ts

@@ -0,0 +1,41 @@
+import { ProDocNode } from './types.js';
+
+export interface DocEditorProps {
+    /** 文档树根节点 */
+    root: ProDocNode;
+    /** 初始选中的文档路径 */
+    initialPath?: string;
+    /** 自定义样式类名 */
+    className?: string;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DocEditorProps>, {
+    className: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    save: (path: string, content: string) => void;
+    docLink: (path: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DocEditorProps>, {
+    className: string;
+}>>> & Readonly<{
+    onDocLink?: ((path: string) => any) | undefined;
+    onSave?: ((path: string, content: string) => any) | undefined;
+}>, {
+    className: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/vendor/@echolab/ui-frame/dist/doc/DocViewer.d.ts

@@ -0,0 +1,39 @@
+import { ProDocNode } from './types.js';
+
+export interface DocViewerProps {
+    /** 文档树根节点 */
+    root: ProDocNode;
+    /** 初始选中的文档路径 */
+    initialPath?: string;
+    /** 自定义样式类名 */
+    className?: string;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DocViewerProps>, {
+    className: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    docLink: (path: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DocViewerProps>, {
+    className: string;
+}>>> & Readonly<{
+    onDocLink?: ((path: string) => any) | undefined;
+}>, {
+    className: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/vendor/@echolab/ui-frame/dist/doc/MarkdownEditor.d.ts

@@ -0,0 +1,37 @@
+export interface MarkdownEditorProps {
+    /** Markdown 内容 */
+    value: string;
+    /** 自定义样式类名 */
+    className?: string;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MarkdownEditorProps>, {
+    className: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: string) => void;
+    docLink: (path: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MarkdownEditorProps>, {
+    className: string;
+}>>> & Readonly<{
+    onChange?: ((value: string) => any) | undefined;
+    onDocLink?: ((path: string) => any) | undefined;
+}>, {
+    className: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/vendor/@echolab/ui-frame/dist/doc/MarkdownRenderer.d.ts

@@ -0,0 +1,42 @@
+export interface MarkdownRendererProps {
+    /** Markdown 内容 */
+    content: string;
+    /** 自定义样式类名 */
+    className?: string;
+    /** 是否显示目录 */
+    showToc?: boolean;
+    /** 滚动容器（HTMLElement 或 CSS 选择器）。不传则自动查找 .nm-layout__content */
+    scrollContainer?: HTMLElement | string;
+}
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MarkdownRendererProps>, {
+    className: string;
+    showToc: boolean;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    docLink: (path: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MarkdownRendererProps>, {
+    className: string;
+    showToc: boolean;
+}>>> & Readonly<{
+    onDocLink?: ((path: string) => any) | undefined;
+}>, {
+    className: string;
+    showToc: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+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];
+} & {};

package/vendor/@echolab/ui-frame/dist/doc/doc-tree.d.ts

@@ -0,0 +1,8 @@
+import { ProDocNode, DocTree } from './types.js';
+
+/** 从根节点构建 DocTree */
+export declare function createDocTree(root: ProDocNode): DocTree;
+/** 扁平化文档树为列表 */
+export declare function flattenDocTree(root: ProDocNode): ProDocNode[];
+/** 获取节点的所有祖先路径 */
+export declare function getAncestors(node: ProDocNode, root: ProDocNode): ProDocNode[];

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

@@ -0,0 +1,27 @@
+/**
+ * @echolab/ui-frame/doc — 文档渲染模块
+ *
+ * 提供 Markdown 渲染、文档查看器和编辑器组件，
+ * 以及文档解析和树形结构工具。
+ *
+ * @example
+ * ```ts
+ * import { DocViewer, MarkdownRenderer, DocEditor, MarkdownEditor } from '@echolab/ui-frame/doc'
+ * import type { ProDocNode, DocTree, DocViewerProps, MarkdownRendererProps } from '@echolab/ui-frame/doc'
+ * ```
+ */
+export { default as DocViewer } from './DocViewer';
+export type { DocViewerProps } from './DocViewer';
+export { default as MarkdownRenderer } from './MarkdownRenderer';
+export type { MarkdownRendererProps } from './MarkdownRenderer';
+export { default as DocEditor } from './DocEditor';
+export type { DocEditorProps } from './DocEditor';
+export { default as MarkdownEditor } from './MarkdownEditor';
+export type { MarkdownEditorProps } from './MarkdownEditor';
+export type { ProDocNode, DocTree, ProDocOptions } from './types.js';
+export { parseFrontmatter, pathToId, extractTitle, createNode, buildDocTree } from './parser.js';
+export { createDocTree, flattenDocTree, getAncestors } from './doc-tree.js';
+export { getNodeIcon, nodeToTreeData } from './tree-utils.js';
+export type { DocTreeNode } from './tree-utils.js';
+export { useDocLayout } from './useDocLayout';
+export type { UseDocLayoutOptions, UseDocLayoutReturn } from './useDocLayout';