@ttsc/graph 0.19.3 → 0.20.0

package/src/structures/ITtscGraphNode.ts

@@ -89,12 +89,37 @@ export interface ITtscGraphNode {
    */
   enumMembers?: ITtscGraphNode.IEnumMember[];
 
+  /**
+   * Direct, statically named members when this variable is initialized with an
+   * object literal, in declaration order.
+   *
+   * The native builder takes identity from the compiler AST and renders the
+   * compact signature from the same Program-owned source snapshot. A spread or
+   * dynamic computed name has no declaration name it can report soundly, so it
+   * contributes no fabricated member.
+   */
+  objectMembers?: ITtscGraphNode.IObjectMember[];
+
   /**
    * Decorators written on this declaration, in source order: raw facts
    * (`@Controller`, `@Get`) a consumer interprets without re-parsing source.
    */
   decorators?: ITtscGraphDecorator[];
 
+  /**
+   * The declaration head, cut by the producer where the compiler says the body
+   * opens.
+   *
+   * Absent when the producer could not bound the head, in which case a consumer
+   * falls back to reading the declaration span. That fallback is a line scan,
+   * and a physical line is not a declaration boundary: it leaks implementation
+   * text when a declaration shares its line with its body, and it stops early
+   * when the head itself contains a brace — a type-literal parameter, an object
+   * return type, a destructured parameter. Prefer this field wherever it is
+   * present.
+   */
+  signature?: string;
+
   /** The declaration span, for display and signatures. */
   evidence?: ITtscGraphEvidence;
 
@@ -117,4 +142,19 @@ export namespace ITtscGraphNode {
      */
     value?: string;
   }
+
+  /** One direct, statically named member of an object-literal variable. */
+  export interface IObjectMember {
+    /** The source-visible static property name. */
+    name: string;
+
+    /** Whether the declaration is a data property or callable/accessor member. */
+    kind: "property" | "method";
+
+    /** 1-based declaration line in the node's file, when source was available. */
+    line?: number;
+
+    /** Compact declaration outline rendered from the compiler source snapshot. */
+    signature?: string;
+  }
 }

package/src/structures/ITtscGraphTrace.ts

@@ -17,7 +17,7 @@ export interface ITtscGraphTrace {
   /** Unique nodes reached (excluding the start), each with its depth and roles. */
   reached: ITtscGraphTrace.INode[];
 
-  /** True when the trace hit its node or depth cap; the returned flow stands. */
+  /** In an open trace, true when a bound omitted an eligible node or hop. */
   truncated: boolean;
 
   /** The resolved `to` target, when a path was requested. */

package/src/view.ts

@@ -3,6 +3,12 @@ import fs from "node:fs";
 import http from "node:http";
 import path from "node:path";
 
+import {
+  nonNegativeIntegerOption,
+  parseLauncherOptions,
+  positiveIntegerOption,
+  projectOptions,
+} from "./launcherArgs";
 import { ensureExecutable } from "./nativeExecutable";
 import { type RawDump, reduce } from "./reduce";
 import { resolveGraphBinary } from "./resolveGraphBinary";
@@ -16,30 +22,26 @@ interface ViewOptions {
 }
 
 function parseViewArgs(argv: readonly string[]): ViewOptions {
-  const opts: ViewOptions = {
-    cwd: process.cwd(),
-    tsconfig: "tsconfig.json",
-    port: 0,
-    open: true,
-    maxNodes: 1200,
+  const values = parseLauncherOptions(argv, [
+    { key: "cwd", flags: ["--cwd"], kind: "value" },
+    { key: "tsconfig", flags: ["--tsconfig", "-p"], kind: "value" },
+    { key: "port", flags: ["--port"], kind: "value" },
+    { key: "open", flags: ["--no-open"], kind: "flag" },
+    { key: "max_nodes", flags: ["--max-nodes"], kind: "value" },
+  ]);
+  const project = projectOptions(values);
+  return {
+    ...project,
+    port:
+      values.has("port") === true
+        ? nonNegativeIntegerOption(values, "port", 65_535)
+        : 0,
+    open: values.get("open") !== true,
+    maxNodes:
+      values.has("max_nodes") === true
+        ? positiveIntegerOption(values, "max_nodes", Number.MAX_SAFE_INTEGER)
+        : 1200,
   };
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i]!;
-    if (arg === "--cwd") opts.cwd = argv[++i] ?? opts.cwd;
-    else if (arg.startsWith("--cwd=")) opts.cwd = arg.slice("--cwd=".length);
-    else if (arg === "--tsconfig" || arg === "-p")
-      opts.tsconfig = argv[++i] ?? opts.tsconfig;
-    else if (arg.startsWith("--tsconfig="))
-      opts.tsconfig = arg.slice("--tsconfig=".length);
-    else if (arg === "--port") opts.port = Number(argv[++i]);
-    else if (arg.startsWith("--port="))
-      opts.port = Number(arg.slice("--port=".length));
-    else if (arg === "--no-open") opts.open = false;
-    else if (arg === "--max-nodes") opts.maxNodes = Number(argv[++i]);
-    else if (arg.startsWith("--max-nodes="))
-      opts.maxNodes = Number(arg.slice("--max-nodes=".length));
-  }
-  return opts;
 }
 
 /**