@n-dx/core 0.1.0

package/packages/web/dist/viewer/components/prd-tree/progressive-loader.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Progressive tree loading for large PRD datasets.
+ *
+ * Renders tree nodes in configurable chunks rather than all at once. A flat
+ * "node budget" controls how many visible nodes are rendered: the tree is
+ * walked in render order and items beyond the budget are excluded. Parents
+ * whose children are partially truncated keep their structural position so
+ * scroll position is stable.
+ *
+ * The module exposes:
+ * - Pure functions for counting and slicing visible nodes (easily testable)
+ * - A Preact hook (`useProgressiveLoader`) for chunk state management
+ * - A `LoadMoreIndicator` component for the "load more" UI
+ *
+ * Search and filter operations always work on the **full** item tree —
+ * progressive loading only limits the **rendering** pass, not the data.
+ *
+ * @see ./prd-tree.ts   — integrating component
+ * @see ./compute.ts    — itemMatchesFilter used for visibility checks
+ */
+import type { VNode } from "preact";
+import type { PRDItemData, ItemStatus } from "./types.js";
+/** Default number of nodes to render per chunk. */
+export declare const DEFAULT_CHUNK_SIZE = 50;
+/**
+ * Minimum item count before progressive loading activates.
+ * Trees smaller than this render in full without any chunking UI.
+ */
+export declare const PROGRESSIVE_THRESHOLD = 50;
+/**
+ * Count visible nodes in a tree, respecting the status filter.
+ *
+ * A node is "visible" when it (or any descendant) matches the active status
+ * filter — the same logic `itemMatchesFilter` uses. Each visible node
+ * contributes 1 to the count, and visible children are counted recursively.
+ *
+ * Complexity: O(N) where N = total nodes in tree.
+ */
+export declare function countVisibleNodes(items: PRDItemData[], activeStatuses: Set<ItemStatus>): number;
+/**
+ * Result of a progressive tree slice operation.
+ */
+export interface ProgressiveSlice {
+    /** Items to render (may be a subset of the original tree). */
+    items: PRDItemData[];
+    /** Number of visible nodes in this slice. */
+    renderedCount: number;
+    /** Total visible nodes in the unsliced tree. */
+    totalCount: number;
+}
+/**
+ * Slice a tree to fit within a node budget.
+ *
+ * Returns the original `items` array unchanged when the total visible count
+ * fits within the limit (common case for small trees).
+ *
+ * @param items          Full PRD item tree
+ * @param activeStatuses Status filter (from StatusFilter component)
+ * @param limit          Maximum number of visible nodes to include
+ * @returns Progressive slice with rendered/total counts
+ */
+export declare function sliceVisibleTree(items: PRDItemData[], activeStatuses: Set<ItemStatus>, limit: number): ProgressiveSlice;
+export interface ProgressiveLoaderState {
+    /** Current node rendering limit. */
+    limit: number;
+    /** Whether there are more nodes beyond the current limit. */
+    hasMore: boolean;
+    /** Load the next chunk of nodes. */
+    loadMore: () => void;
+    /** Load all remaining nodes at once. */
+    loadAll: () => void;
+    /** Whether a chunk load is in progress (brief transition state). */
+    isLoading: boolean;
+    /** Number of visible nodes that will be rendered. */
+    renderedCount: number;
+    /** Total visible nodes in the full tree. */
+    totalCount: number;
+    /** Whether progressive loading is active (tree exceeds threshold). */
+    isActive: boolean;
+}
+/**
+ * Manages progressive loading state for a tree of the given size.
+ *
+ * The hook auto-resets the limit when `totalCount` changes (e.g. after a
+ * filter change or data refresh), ensuring the user always starts from a
+ * reasonable chunk size.
+ *
+ * A brief `isLoading` transition (one frame) is triggered on `loadMore` /
+ * `loadAll` to give the browser a paint opportunity before the potentially
+ * heavy render of additional nodes.
+ *
+ * @param totalCount Total visible nodes (from countVisibleNodes)
+ * @param chunkSize  Number of nodes per chunk (DEFAULT_CHUNK_SIZE)
+ */
+export declare function useProgressiveLoader(totalCount: number, chunkSize?: number): ProgressiveLoaderState;
+export interface LoadMoreIndicatorProps {
+    /** Number of nodes currently rendered. */
+    renderedCount: number;
+    /** Total visible nodes in the tree. */
+    totalCount: number;
+    /** Number of nodes to add per chunk. */
+    chunkSize: number;
+    /** Whether a load operation is in progress. */
+    isLoading: boolean;
+    /** Load the next chunk. */
+    onLoadMore: () => void;
+    /** Load all remaining nodes. */
+    onLoadAll: () => void;
+}
+/**
+ * "Load More" indicator shown below the tree when progressive loading is
+ * active and there are more nodes to reveal.
+ */
+export declare function LoadMoreIndicator({ renderedCount, totalCount, chunkSize, isLoading, onLoadMore, onLoadAll, }: LoadMoreIndicatorProps): VNode;

package/packages/web/dist/viewer/components/prd-tree/progressive-loader.js

@@ -0,0 +1,225 @@
+/**
+ * Progressive tree loading for large PRD datasets.
+ *
+ * Renders tree nodes in configurable chunks rather than all at once. A flat
+ * "node budget" controls how many visible nodes are rendered: the tree is
+ * walked in render order and items beyond the budget are excluded. Parents
+ * whose children are partially truncated keep their structural position so
+ * scroll position is stable.
+ *
+ * The module exposes:
+ * - Pure functions for counting and slicing visible nodes (easily testable)
+ * - A Preact hook (`useProgressiveLoader`) for chunk state management
+ * - A `LoadMoreIndicator` component for the "load more" UI
+ *
+ * Search and filter operations always work on the **full** item tree —
+ * progressive loading only limits the **rendering** pass, not the data.
+ *
+ * @see ./prd-tree.ts   — integrating component
+ * @see ./compute.ts    — itemMatchesFilter used for visibility checks
+ */
+import { h } from "preact";
+import { useState, useCallback, useEffect, useRef } from "preact/hooks";
+import { itemMatchesFilter } from "./compute.js";
+/** Default number of nodes to render per chunk. */
+export const DEFAULT_CHUNK_SIZE = 50;
+/**
+ * Minimum item count before progressive loading activates.
+ * Trees smaller than this render in full without any chunking UI.
+ */
+export const PROGRESSIVE_THRESHOLD = 50;
+// ── Pure counting ────────────────────────────────────────────────────
+/**
+ * Count visible nodes in a tree, respecting the status filter.
+ *
+ * A node is "visible" when it (or any descendant) matches the active status
+ * filter — the same logic `itemMatchesFilter` uses. Each visible node
+ * contributes 1 to the count, and visible children are counted recursively.
+ *
+ * Complexity: O(N) where N = total nodes in tree.
+ */
+export function countVisibleNodes(items, activeStatuses) {
+    let count = 0;
+    for (const item of items) {
+        if (!itemMatchesFilter(item, activeStatuses))
+            continue;
+        count++;
+        if (item.children && item.children.length > 0) {
+            count += countVisibleNodes(item.children, activeStatuses);
+        }
+    }
+    return count;
+}
+/**
+ * Internal recursive slicer. Walks `items` in render order, consuming from
+ * `budget.remaining` for each visible node. Stops including siblings once
+ * the budget reaches zero. Children are sliced recursively with the shared
+ * budget object, so a deep subtree naturally shares the budget with its
+ * later siblings.
+ *
+ * Structural sharing: when all children of a node survive the slice, the
+ * original item reference is reused (no shallow copy). Only items at the
+ * truncation boundary get a new object.
+ */
+function sliceItems(items, activeStatuses, budget) {
+    const result = [];
+    for (const item of items) {
+        if (budget.remaining <= 0)
+            break;
+        if (!itemMatchesFilter(item, activeStatuses))
+            continue;
+        // This node consumes 1 from the budget.
+        budget.remaining--;
+        if (item.children && item.children.length > 0) {
+            // Snapshot budget before recursing to detect whether children were truncated.
+            const budgetBefore = budget.remaining;
+            const childSlice = sliceItems(item.children, activeStatuses, budget);
+            const childrenConsumed = budgetBefore - budget.remaining;
+            // Count how many of this item's children are visible (for truncation check).
+            const visibleChildCount = countVisibleChildren(item.children, activeStatuses);
+            if (childrenConsumed === visibleChildCount) {
+                // All visible children survived — reuse the original item reference.
+                result.push(item);
+            }
+            else {
+                // Some children truncated — shallow-copy with sliced children.
+                result.push({
+                    ...item,
+                    children: childSlice.length > 0 ? childSlice : undefined,
+                });
+            }
+        }
+        else {
+            result.push(item);
+        }
+    }
+    return result;
+}
+/**
+ * Count visible direct + nested children of an item (for truncation detection).
+ * Similar to countVisibleNodes but operates on a single parent's children.
+ */
+function countVisibleChildren(children, activeStatuses) {
+    return countVisibleNodes(children, activeStatuses);
+}
+/**
+ * Slice a tree to fit within a node budget.
+ *
+ * Returns the original `items` array unchanged when the total visible count
+ * fits within the limit (common case for small trees).
+ *
+ * @param items          Full PRD item tree
+ * @param activeStatuses Status filter (from StatusFilter component)
+ * @param limit          Maximum number of visible nodes to include
+ * @returns Progressive slice with rendered/total counts
+ */
+export function sliceVisibleTree(items, activeStatuses, limit) {
+    const totalCount = countVisibleNodes(items, activeStatuses);
+    if (totalCount <= limit) {
+        return { items, renderedCount: totalCount, totalCount };
+    }
+    const budget = { remaining: limit };
+    const sliced = sliceItems(items, activeStatuses, budget);
+    const renderedCount = limit - budget.remaining;
+    return { items: sliced, renderedCount, totalCount };
+}
+/**
+ * Manages progressive loading state for a tree of the given size.
+ *
+ * The hook auto-resets the limit when `totalCount` changes (e.g. after a
+ * filter change or data refresh), ensuring the user always starts from a
+ * reasonable chunk size.
+ *
+ * A brief `isLoading` transition (one frame) is triggered on `loadMore` /
+ * `loadAll` to give the browser a paint opportunity before the potentially
+ * heavy render of additional nodes.
+ *
+ * @param totalCount Total visible nodes (from countVisibleNodes)
+ * @param chunkSize  Number of nodes per chunk (DEFAULT_CHUNK_SIZE)
+ */
+export function useProgressiveLoader(totalCount, chunkSize = DEFAULT_CHUNK_SIZE) {
+    const isActive = totalCount > PROGRESSIVE_THRESHOLD;
+    const [limit, setLimit] = useState(() => isActive ? chunkSize : totalCount);
+    const [isLoading, setIsLoading] = useState(false);
+    const rafRef = useRef(0);
+    // Reset limit when total changes (filter/data update).
+    // Use a ref to track the previous total to avoid unnecessary resets.
+    const prevTotalRef = useRef(totalCount);
+    useEffect(() => {
+        if (prevTotalRef.current !== totalCount) {
+            prevTotalRef.current = totalCount;
+            setLimit(isActive ? chunkSize : totalCount);
+            setIsLoading(false);
+        }
+    }, [totalCount, chunkSize, isActive]);
+    // Cleanup rAF on unmount.
+    useEffect(() => {
+        return () => {
+            if (rafRef.current)
+                cancelAnimationFrame(rafRef.current);
+        };
+    }, []);
+    const loadMore = useCallback(() => {
+        setIsLoading(true);
+        // Defer the actual limit increase by one frame so the browser can
+        // paint the loading indicator before the heavy render kicks in.
+        rafRef.current = requestAnimationFrame(() => {
+            setLimit((prev) => Math.min(prev + chunkSize, totalCount));
+            setIsLoading(false);
+        });
+    }, [chunkSize, totalCount]);
+    const loadAll = useCallback(() => {
+        setIsLoading(true);
+        rafRef.current = requestAnimationFrame(() => {
+            setLimit(totalCount);
+            setIsLoading(false);
+        });
+    }, [totalCount]);
+    const effectiveLimit = isActive ? Math.min(limit, totalCount) : totalCount;
+    return {
+        limit: effectiveLimit,
+        hasMore: isActive && effectiveLimit < totalCount,
+        loadMore,
+        loadAll,
+        isLoading,
+        renderedCount: Math.min(effectiveLimit, totalCount),
+        totalCount,
+        isActive,
+    };
+}
+/**
+ * "Load More" indicator shown below the tree when progressive loading is
+ * active and there are more nodes to reveal.
+ */
+export function LoadMoreIndicator({ renderedCount, totalCount, chunkSize, isLoading, onLoadMore, onLoadAll, }) {
+    const remaining = totalCount - renderedCount;
+    const nextChunk = Math.min(remaining, chunkSize);
+    return h("div", { class: "prd-load-more", role: "status", "aria-live": "polite" }, 
+    // Progress info
+    h("div", { class: "prd-load-more-info" }, `Showing ${renderedCount} of ${totalCount} nodes`), 
+    // Progress bar
+    h("div", {
+        class: "prd-load-more-progress",
+        role: "progressbar",
+        "aria-valuenow": String(renderedCount),
+        "aria-valuemin": "0",
+        "aria-valuemax": String(totalCount),
+        "aria-label": `${renderedCount} of ${totalCount} nodes loaded`,
+    }, h("div", {
+        class: "prd-load-more-progress-fill",
+        style: `width: ${Math.round((renderedCount / totalCount) * 100)}%`,
+    })), 
+    // Action buttons
+    h("div", { class: "prd-load-more-actions" }, h("button", {
+        class: "prd-load-more-btn prd-load-more-btn-primary",
+        onClick: onLoadMore,
+        disabled: isLoading,
+        "aria-label": `Load ${nextChunk} more nodes`,
+    }, isLoading ? "Loading\u2026" : `Load ${nextChunk} more`), h("button", {
+        class: "prd-load-more-btn prd-load-more-btn-secondary",
+        onClick: onLoadAll,
+        disabled: isLoading,
+        "aria-label": `Load all ${remaining} remaining nodes`,
+    }, isLoading ? "Loading\u2026" : `Load all (${remaining})`)));
+}
+//# sourceMappingURL=progressive-loader.js.map

package/packages/web/dist/viewer/components/prd-tree/progressive-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progressive-loader.js","sourceRoot":"","sources":["../../../../src/viewer/components/prd-tree/progressive-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAExE,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,mDAAmD;AACnD,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAErC;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC,wEAAwE;AAExE;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAoB,EACpB,cAA+B;IAE/B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,cAAc,CAAC;YAAE,SAAS;QACvD,KAAK,EAAE,CAAC;QACR,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9C,KAAK,IAAI,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAwBD;;;;;;;;;;GAUG;AACH,SAAS,UAAU,CACjB,KAAoB,EACpB,cAA+B,EAC/B,MAAmB;IAEnB,MAAM,MAAM,GAAkB,EAAE,CAAC;IAEjC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,MAAM,CAAC,SAAS,IAAI,CAAC;YAAE,MAAM;QACjC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,cAAc,CAAC;YAAE,SAAS;QAEvD,wCAAwC;QACxC,MAAM,CAAC,SAAS,EAAE,CAAC;QAEnB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9C,8EAA8E;YAC9E,MAAM,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC;YACtC,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;YACrE,MAAM,gBAAgB,GAAG,YAAY,GAAG,MAAM,CAAC,SAAS,CAAC;YAEzD,6EAA6E;YAC7E,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;YAE9E,IAAI,gBAAgB,KAAK,iBAAiB,EAAE,CAAC;gBAC3C,qEAAqE;gBACrE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACN,+DAA+D;gBAC/D,MAAM,CAAC,IAAI,CAAC;oBACV,GAAG,IAAI;oBACP,QAAQ,EAAE,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;iBACzD,CAAC,CAAC;YACL,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAC3B,QAAuB,EACvB,cAA+B;IAE/B,OAAO,iBAAiB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAoB,EACpB,cAA+B,EAC/B,KAAa;IAEb,MAAM,UAAU,GAAG,iBAAiB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAE5D,IAAI,UAAU,IAAI,KAAK,EAAE,CAAC;QACxB,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;IAC1D,CAAC;IAED,MAAM,MAAM,GAAgB,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACjD,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;IACzD,MAAM,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC;IAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;AACtD,CAAC;AAuBD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,oBAAoB,CAClC,UAAkB,EAClB,YAAoB,kBAAkB;IAEtC,MAAM,QAAQ,GAAG,UAAU,GAAG,qBAAqB,CAAC;IACpD,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CACtC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAClC,CAAC;IACF,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClD,MAAM,MAAM,GAAG,MAAM,CAAS,CAAC,CAAC,CAAC;IAEjC,uDAAuD;IACvD,qEAAqE;IACrE,MAAM,YAAY,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACxC,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,YAAY,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;YACxC,YAAY,CAAC,OAAO,GAAG,UAAU,CAAC;YAClC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;YAC5C,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEtC,0BAA0B;IAC1B,SAAS,CAAC,GAAG,EAAE;QACb,OAAO,GAAG,EAAE;YACV,IAAI,MAAM,CAAC,OAAO;gBAAE,oBAAoB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC3D,CAAC,CAAC;IACJ,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE;QAChC,YAAY,CAAC,IAAI,CAAC,CAAC;QACnB,kEAAkE;QAClE,gEAAgE;QAChE,MAAM,CAAC,OAAO,GAAG,qBAAqB,CAAC,GAAG,EAAE;YAC1C,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;YAC3D,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;IAE5B,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE;QAC/B,YAAY,CAAC,IAAI,CAAC,CAAC;QACnB,MAAM,CAAC,OAAO,GAAG,qBAAqB,CAAC,GAAG,EAAE;YAC1C,QAAQ,CAAC,UAAU,CAAC,CAAC;YACrB,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,MAAM,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;IAE3E,OAAO;QACL,KAAK,EAAE,cAAc;QACrB,OAAO,EAAE,QAAQ,IAAI,cAAc,GAAG,UAAU;QAChD,QAAQ;QACR,OAAO;QACP,SAAS;QACT,aAAa,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,UAAU,CAAC;QACnD,UAAU;QACV,QAAQ;KACT,CAAC;AACJ,CAAC;AAmBD;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAChC,aAAa,EACb,UAAU,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,GACc;IACvB,MAAM,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC;IAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IAEjD,OAAO,CAAC,CACN,KAAK,EACL,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE;IACjE,gBAAgB;IAChB,CAAC,CACC,KAAK,EACL,EAAE,KAAK,EAAE,oBAAoB,EAAE,EAC/B,WAAW,aAAa,OAAO,UAAU,QAAQ,CAClD;IACD,eAAe;IACf,CAAC,CACC,KAAK,EACL;QACE,KAAK,EAAE,wBAAwB;QAC/B,IAAI,EAAE,aAAa;QACnB,eAAe,EAAE,MAAM,CAAC,aAAa,CAAC;QACtC,eAAe,EAAE,GAAG;QACpB,eAAe,EAAE,MAAM,CAAC,UAAU,CAAC;QACnC,YAAY,EAAE,GAAG,aAAa,OAAO,UAAU,eAAe;KAC/D,EACD,CAAC,CAAC,KAAK,EAAE;QACP,KAAK,EAAE,6BAA6B;QACpC,KAAK,EAAE,UAAU,IAAI,CAAC,KAAK,CAAC,CAAC,aAAa,GAAG,UAAU,CAAC,GAAG,GAAG,CAAC,GAAG;KACnE,CAAC,CACH;IACD,iBAAiB;IACjB,CAAC,CACC,KAAK,EACL,EAAE,KAAK,EAAE,uBAAuB,EAAE,EAClC,CAAC,CACC,QAAQ,EACR;QACE,KAAK,EAAE,6CAA6C;QACpD,OAAO,EAAE,UAAU;QACnB,QAAQ,EAAE,SAAS;QACnB,YAAY,EAAE,QAAQ,SAAS,aAAa;KAC7C,EACD,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,QAAQ,SAAS,OAAO,CACvD,EACD,CAAC,CACC,QAAQ,EACR;QACE,KAAK,EAAE,+CAA+C;QACtD,OAAO,EAAE,SAAS;QAClB,QAAQ,EAAE,SAAS;QACnB,YAAY,EAAE,YAAY,SAAS,kBAAkB;KACtD,EACD,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,aAAa,SAAS,GAAG,CACxD,CACF,CACF,CAAC;AACJ,CAAC"}

package/packages/web/dist/viewer/components/prd-tree/proposal-editor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Proposal editor — editable tree for reviewing and modifying proposals
+ * before accepting them into the PRD.
+ *
+ * Provides inline editing for titles, descriptions, and metadata.
+ * Each node (epic/feature/task) can be independently selected or deselected.
+ * Validates that selected items have non-empty titles before acceptance.
+ */
+export interface ProposalEditorProps {
+    /** Proposals to edit — the raw data from analysis. */
+    proposals: RawProposal[];
+    /** Called when edited proposals are accepted and PRD should be refreshed. */
+    onAccepted: () => void;
+    /** Called to close the editor without accepting. */
+    onCancel: () => void;
+}
+/** Raw proposal shape from the analyze endpoint. */
+export interface RawProposal {
+    epic: {
+        title: string;
+        source: string;
+        description?: string;
+    };
+    features: RawProposalFeature[];
+}
+interface RawProposalFeature {
+    title: string;
+    source: string;
+    description?: string;
+    tasks: RawProposalTask[];
+}
+interface RawProposalTask {
+    title: string;
+    source: string;
+    sourceFile: string;
+    description?: string;
+    acceptanceCriteria?: string[];
+    priority?: string;
+    tags?: string[];
+}
+export declare function ProposalEditor({ proposals: rawProposals, onAccepted, onCancel }: ProposalEditorProps): import("preact").VNode<import("preact").ClassAttributes<HTMLElement> & {
+    class: string;
+}>;
+export {};