@tsplc/debug 0.2.16 → 0.2.18

package/src/ui/tree.ts

@@ -3,154 +3,186 @@ import { joinPath, pathSegments, typeOf } from "../paths.ts";
 
 /** One row of the instance tree: a root, a record field, an array element or a folded constant. */
 export interface TreeNode {
-  path: string;
-  /** The last segment: a field name, `[3]`, or the whole path for a top-level node. */
-  name: string;
-  type: string;
-  declaration?: SourceRange;
-  /** Whether the target adapter can read it at runtime. */
-  readable: boolean;
-  generated: boolean;
-  constant?: DebugConstant;
+	path: string;
+	/** The last segment: a field name, `[3]`, or the whole path for a top-level node. */
+	name: string;
+	type: string;
+	declaration?: SourceRange;
+	/** Whether the target adapter can read it at runtime. */
+	readable: boolean;
+	generated: boolean;
+	constant?: DebugConstant;
 }
 
 export interface TreeRow {
-  node: TreeNode;
-  depth: number;
+	node: TreeNode;
+	depth: number;
 }
 
 export const parentPath = (path: string) =>
-  path.slice(0, Math.max(path.lastIndexOf("."), path.lastIndexOf("[")));
+	path.slice(0, Math.max(path.lastIndexOf("."), path.lastIndexOf("[")));
 
 /** Every proper prefix of `path` at a `.` or `[` boundary, shortest first. */
 export const ancestorPaths = (path: string) =>
-  [...path.matchAll(/[.[]/g)].map((match) => path.slice(0, match.index));
+	[...path.matchAll(/[.[]/g)].map((match) => path.slice(0, match.index));
 
 /** The manifest's instances as a lazily expanded tree, addressed by TypeScript path. */
 export class ManifestTree {
-  readonly top: TreeNode[];
-  private readonly constantsByParent = new Map<string, DebugConstant[]>();
-  private readonly children = new Map<string, TreeNode[]>();
+	readonly top: TreeNode[];
+	private readonly constantsByParent = new Map<string, DebugConstant[]>();
+	private readonly children = new Map<string, TreeNode[]>();
 
-  constructor(readonly manifest: DebugManifest) {
-    const roots = manifest.roots.map((root) => ({
-      path: root.path,
-      name: root.path,
-      type: root.type,
-      declaration: root.declaration,
-      readable: root.readable,
-      generated: root.generated === true,
-    }));
-    for (const constant of manifest.constants) {
-      const parent = parentPath(constant.path);
-      this.constantsByParent.set(parent, [...(this.constantsByParent.get(parent) ?? []), constant]);
-    }
-    const orphans = manifest.constants.filter(
-      (constant) => !this.resolveVariable(roots, parentPath(constant.path)),
-    );
-    this.top = [...roots, ...orphans.map((constant) => this.constantNode(constant, constant.path))];
-  }
+	constructor(readonly manifest: DebugManifest) {
+		const roots = manifest.roots.map((root) => ({
+			path: root.path,
+			name: root.path,
+			type: root.type,
+			declaration: root.declaration,
+			readable: root.readable,
+			generated: root.generated === true,
+		}));
+		for (const constant of manifest.constants) {
+			const parent = parentPath(constant.path);
+			this.constantsByParent.set(parent, [
+				...(this.constantsByParent.get(parent) ?? []),
+				constant,
+			]);
+		}
+		const orphans = manifest.constants.filter(
+			(constant) => !this.resolveVariable(roots, parentPath(constant.path)),
+		);
+		this.top = [
+			...roots,
+			...orphans.map((constant) => this.constantNode(constant, constant.path)),
+		];
+	}
 
-  expandable(node: TreeNode) {
-    if (node.constant) return false;
-    const kind = typeOf(this.manifest, node.type).kind;
-    return kind === "record" || kind === "array";
-  }
+	expandable(node: TreeNode) {
+		if (node.constant) {
+			return false;
+		}
+		const kind = typeOf(this.manifest, node.type).kind;
+		return kind === "record" || kind === "array";
+	}
 
-  childrenOf(node: TreeNode): TreeNode[] {
-    const cached = this.children.get(node.path);
-    if (cached) return cached;
-    const type = typeOf(this.manifest, node.type);
-    const variables: TreeNode[] =
-      type.kind === "record"
-        ? type.fields.map((field) => ({
-            path: `${node.path}.${field.name}`,
-            name: field.name,
-            type: field.type,
-            declaration: field.declaration,
-            readable: node.readable,
-            generated: node.generated || field.generated === true,
-          }))
-        : type.kind === "array"
-          ? Array.from({ length: type.length }, (_, offset) => ({
-              path: `${node.path}[${type.lower + offset}]`,
-              name: `[${type.lower + offset}]`,
-              type: type.element,
-              declaration: node.declaration,
-              readable: node.readable,
-              generated: node.generated,
-            }))
-          : [];
-    const constants = (this.constantsByParent.get(node.path) ?? []).map((constant) =>
-      this.constantNode(constant, constant.path.slice(node.path.length + 1)),
-    );
-    const children = [...variables, ...constants];
-    this.children.set(node.path, children);
-    return children;
-  }
+	childrenOf(node: TreeNode): TreeNode[] {
+		const cached = this.children.get(node.path);
+		if (cached) {
+			return cached;
+		}
+		const constants = (this.constantsByParent.get(node.path) ?? []).map(
+			(constant) =>
+				this.constantNode(constant, constant.path.slice(node.path.length + 1)),
+		);
+		const children = [...this.variablesOf(node), ...constants];
+		this.children.set(node.path, children);
+		return children;
+	}
 
-  /** The rows shown for an expansion state, depth first. */
-  rows(expanded: ReadonlySet<string>, showGenerated: boolean): TreeRow[] {
-    const rows: TreeRow[] = [];
-    const visit = (nodes: TreeNode[], depth: number) => {
-      for (const node of nodes) {
-        if (node.generated && !showGenerated) continue;
-        rows.push({ node, depth });
-        if (expanded.has(node.path) && this.expandable(node))
-          visit(this.childrenOf(node), depth + 1);
-      }
-    };
-    visit(this.top, 0);
-    return rows;
-  }
+	/** The rows shown for an expansion state, depth first. */
+	rows(expanded: ReadonlySet<string>, showGenerated: boolean): TreeRow[] {
+		const rows: TreeRow[] = [];
+		const visit = (nodes: TreeNode[], depth: number) => {
+			for (const node of nodes) {
+				if (node.generated && !showGenerated) {
+					continue;
+				}
+				rows.push({ node, depth });
+				if (expanded.has(node.path) && this.expandable(node)) {
+					visit(this.childrenOf(node), depth + 1);
+				}
+			}
+		};
+		visit(this.top, 0);
+		return rows;
+	}
 
-  /** Nodes whose path contains `query` (case-insensitive), in tree order, at most `limit`. */
-  search(query: string, showGenerated: boolean, limit: number) {
-    const needle = query.toLowerCase();
-    const found: TreeNode[] = [];
-    let total = 0;
-    const visit = (nodes: TreeNode[]) => {
-      for (const node of nodes) {
-        if (node.generated && !showGenerated) continue;
-        if (node.path.toLowerCase().includes(needle) && total++ < limit) found.push(node);
-        if (this.expandable(node)) visit(this.childrenOf(node));
-      }
-    };
-    visit(this.top);
-    return { nodes: found, total };
-  }
+	/** Nodes whose path contains `query` (case-insensitive), in tree order, at most `limit`. */
+	search(query: string, showGenerated: boolean, limit: number) {
+		const needle = query.toLowerCase();
+		const found: TreeNode[] = [];
+		let total = 0;
+		const visit = (nodes: TreeNode[]) => {
+			for (const node of nodes) {
+				if (node.generated && !showGenerated) {
+					continue;
+				}
+				if (node.path.toLowerCase().includes(needle) && total++ < limit) {
+					found.push(node);
+				}
+				if (this.expandable(node)) {
+					visit(this.childrenOf(node));
+				}
+			}
+		};
+		visit(this.top);
+		return { nodes: found, total };
+	}
 
-  resolve(path: string): TreeNode | undefined {
-    const constant = this.manifest.constants.find((entry) => entry.path === path);
-    if (constant) return this.constantNode(constant, path);
-    return this.resolveVariable(this.top, path);
-  }
+	resolve(path: string): TreeNode | undefined {
+		const constant = this.manifest.constants.find(
+			(entry) => entry.path === path,
+		);
+		if (constant) {
+			return this.constantNode(constant, path);
+		}
+		return this.resolveVariable(this.top, path);
+	}
 
-  private resolveVariable(top: TreeNode[], path: string): TreeNode | undefined {
-    let node = top.find(
-      (root) =>
-        path === root.path ||
-        (path.startsWith(root.path) && /^[.[]/.test(path.slice(root.path.length))),
-    );
-    while (node && node.path !== path) {
-      const rest = path.slice(node.path.length);
-      const [segment] = pathSegments(rest);
-      if (!segment) return undefined;
-      const childPath = joinPath(node.path, segment);
-      node = this.childrenOf(node).find((child) => child.path === childPath);
-    }
-    return node;
-  }
+	private resolveVariable(top: TreeNode[], path: string): TreeNode | undefined {
+		let node = top.find(
+			(root) =>
+				path === root.path ||
+				(path.startsWith(root.path) &&
+					/^[.[]/.test(path.slice(root.path.length))),
+		);
+		while (node && node.path !== path) {
+			const rest = path.slice(node.path.length);
+			const [segment] = pathSegments(rest);
+			if (!segment) {
+				return undefined;
+			}
+			const childPath = joinPath(node.path, segment);
+			node = this.childrenOf(node).find((child) => child.path === childPath);
+		}
+		return node;
+	}
 
-  private constantNode(constant: DebugConstant, name: string): TreeNode {
-    return {
-      path: constant.path,
-      name,
-      type: constant.type,
-      declaration: constant.declaration,
-      readable: false,
-      generated: false,
-      constant,
-    };
-  }
+	/** A record's fields or an array's elements, which share its readability and generated mark. */
+	private variablesOf(node: TreeNode): TreeNode[] {
+		const type = typeOf(this.manifest, node.type);
+		if (type.kind === "record") {
+			return type.fields.map((field) => ({
+				path: `${node.path}.${field.name}`,
+				name: field.name,
+				type: field.type,
+				declaration: field.declaration,
+				readable: node.readable,
+				generated: node.generated || field.generated === true,
+			}));
+		}
+		if (type.kind === "array") {
+			return Array.from({ length: type.length }, (_, offset) => ({
+				path: `${node.path}[${type.lower + offset}]`,
+				name: `[${type.lower + offset}]`,
+				type: type.element,
+				declaration: node.declaration,
+				readable: node.readable,
+				generated: node.generated,
+			}));
+		}
+		return [];
+	}
+
+	private constantNode(constant: DebugConstant, name: string): TreeNode {
+		return {
+			path: constant.path,
+			name,
+			type: constant.type,
+			declaration: constant.declaration,
+			readable: false,
+			generated: false,
+			constant,
+		};
+	}
 }