@typeslayer/analyze-trace 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,669 @@
+// src/analyze-trace.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import {
+  TRACE_JSON_FILENAME,
+  TYPES_JSON_FILENAME,
+  traceJsonSchema,
+  typesJsonSchema
+} from "@typeslayer/validate";
+
+// src/constants.ts
+var ANALYZE_TRACE_FILENAME = "analyze-trace.json";
+
+// src/depth-limits.ts
+import {
+  depthLimits,
+  event_checktypes__checkCrossProductUnion_DepthLimit,
+  event_checktypes__checkTypeRelatedTo_DepthLimit,
+  event_checktypes__getTypeAtFlowNode_DepthLimit,
+  event_checktypes__instantiateType_DepthLimit,
+  event_checktypes__recursiveTypeRelatedTo_DepthLimit,
+  event_checktypes__removeSubtypes_DepthLimit,
+  event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit,
+  event_checktypes__typeRelatedToDiscriminatedType_DepthLimit
+} from "@typeslayer/validate";
+var createDepthLimits = (traceFile) => {
+  const limitNamesSet = new Set(
+    depthLimits.map((d) => d.shape.name)
+  );
+  const limitEvents = traceFile.filter((event) => limitNamesSet.has(event.name));
+  return {
+    checkCrossProductUnion_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__checkCrossProductUnion_DepthLimit.safeParse(event).success
+    ).sort((a, b) => a.args.size - b.args.size),
+    checkTypeRelatedTo_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__checkTypeRelatedTo_DepthLimit.safeParse(event).success
+    ).sort((a, b) => a.args.depth - b.args.depth),
+    getTypeAtFlowNode_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__getTypeAtFlowNode_DepthLimit.safeParse(event).success
+    ).sort((a, b) => a.args.flowId - b.args.flowId),
+    instantiateType_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__instantiateType_DepthLimit.safeParse(event).success
+    ).sort((a, b) => a.args.instantiationDepth - b.args.instantiationDepth),
+    recursiveTypeRelatedTo_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__recursiveTypeRelatedTo_DepthLimit.safeParse(event).success
+    ).sort((a, b) => a.args.depth - b.args.depth),
+    removeSubtypes_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__removeSubtypes_DepthLimit.safeParse(event).success
+    ),
+    traceUnionsOrIntersectionsTooLarge_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit.safeParse(
+        event
+      ).success
+    ).sort(
+      (a, b) => a.args.sourceSize * a.args.targetSize - b.args.sourceSize * b.args.targetSize
+    ),
+    typeRelatedToDiscriminatedType_DepthLimit: limitEvents.filter(
+      (event) => event_checktypes__typeRelatedToDiscriminatedType_DepthLimit.safeParse(
+        event
+      ).success
+    ).sort((a, b) => a.args.numCombinations - b.args.numCombinations)
+  };
+};
+
+// src/get-duplicate-node-modules.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function getPackageVersion(packagePath2) {
+  const packageJsonPath = join(packagePath2, "package.json");
+  console.log("packageJsonPath", packageJsonPath);
+  if (!existsSync(packageJsonPath)) {
+    console.warn(
+      `Package.json not found at ${packageJsonPath}. This may not be a node module.`
+    );
+    return "unknown";
+  }
+  const jsonString = await readFile(packageJsonPath, "utf-8");
+  const jsonObj = JSON.parse(jsonString);
+  return jsonObj.version;
+}
+var getDuplicateNodeModules = async (nodeModulePaths2) => {
+  const duplicates = [];
+  for (const [packageName2, packagePaths] of Object.entries(nodeModulePaths2)) {
+    if (packagePaths.length < 2) {
+      continue;
+    }
+    const instances = [];
+    for (const packagePath2 of packagePaths) {
+      instances.push({
+        path: packagePath2,
+        version: await getPackageVersion(packagePath2)
+      });
+    }
+    duplicates.push({
+      name: packageName2,
+      instances
+    });
+  }
+  return duplicates;
+};
+
+// src/get-hotspots.ts
+import { normalize } from "path";
+import {
+  createTypeRegistry
+} from "@typeslayer/validate";
+var getHotspots = async (hotPathsTree, typesFile, options) => getHotspotsWorker({
+  span: hotPathsTree,
+  currentFile: void 0,
+  typeRegistry: createTypeRegistry(typesFile),
+  options
+});
+async function getHotspotsWorker({
+  span,
+  currentFile,
+  typeRegistry,
+  options
+}) {
+  if (span.event.cat === "check") {
+    currentFile = span.event.args.path;
+  }
+  const children = [];
+  if (span.children.length) {
+    const sortedChildren = span.children.sort(
+      (a, b) => b.duration - a.duration
+    );
+    for (const child of sortedChildren) {
+      children.push(
+        ...await getHotspotsWorker({
+          span: child,
+          currentFile,
+          typeRegistry,
+          options
+        })
+      );
+    }
+  }
+  if (span.event.name !== "root") {
+    const hotFrame = await makeHotFrame({
+      span,
+      children,
+      typeRegistry
+    });
+    if (hotFrame) {
+      return [hotFrame];
+    }
+  }
+  return children;
+}
+var notFound = {
+  children: [],
+  resolvedType: {
+    id: -1,
+    display: "[Type Not Found]",
+    flags: []
+  }
+};
+function getHotType({
+  id,
+  typeRegistry
+}) {
+  function worker(id2, ancestorIds) {
+    if (id2 === -1) {
+      return notFound;
+    }
+    const resolvedType2 = typeRegistry[id2];
+    if (!resolvedType2) {
+      throw new Error(`Type ${id2} not found`);
+    }
+    const children = [];
+    if (ancestorIds.indexOf(id2) < 0) {
+      ancestorIds.push(id2);
+      const properties = Object.keys(resolvedType2);
+      for (const property of properties) {
+        switch (property) {
+          case "aliasTypeArguments":
+          case "intersectionTypes":
+          case "typeArguments":
+          case "unionTypes": {
+            const typeIds = resolvedType2[property];
+            if (!Array.isArray(typeIds)) {
+              throw new Error(`Expected array for ${property}`);
+            }
+            for (const typeId of typeIds) {
+              const child = worker(typeId, ancestorIds);
+              if (child) {
+                children.push(child);
+              }
+            }
+            continue;
+          }
+          case "aliasType":
+          case "conditionalCheckType":
+          case "conditionalExtendsType":
+          case "conditionalFalseType":
+          case "conditionalTrueType":
+          case "constraintType":
+          case "evolvingArrayElementType":
+          case "evolvingArrayFinalType":
+          case "indexedAccessIndexType":
+          case "indexedAccessObjectType":
+          case "instantiatedType":
+          case "keyofType":
+          case "reverseMappedConstraintType":
+          case "reverseMappedMappedType":
+          case "reverseMappedSourceType":
+          case "substitutionBaseType": {
+            const typeId = resolvedType2[property];
+            const child = worker(typeId, ancestorIds);
+            if (child) {
+              children.push(child);
+            }
+            break;
+          }
+          case "destructuringPattern":
+          case "display":
+          case "firstDeclaration":
+          case "flags":
+          case "id":
+          case "intrinsicName":
+          case "isTuple":
+          case "recursionId":
+          case "referenceLocation":
+          case "symbolName":
+            break;
+          default:
+            property;
+            throw new Error(`Unexpected property ${property}`);
+        }
+      }
+      ancestorIds.pop();
+    }
+    return {
+      resolvedType: resolvedType2,
+      children
+    };
+  }
+  return worker(id, []);
+}
+async function makeHotFrame({
+  span,
+  children,
+  typeRegistry
+}) {
+  const { event, duration } = span;
+  const timeMs = Math.round(duration / 1e3);
+  switch (event.name) {
+    // case "findSourceFile":
+    //     TODO (https://github.com/microsoft/typescript-analyze-trace/issues/2)
+    case "checkSourceFile": {
+      const filePath = event.args.path;
+      const normalizedPath = normalize(filePath);
+      return {
+        description: `Check file ${normalizedPath}`,
+        timeMs,
+        path: normalizedPath,
+        children
+      };
+    }
+    case "structuredTypeRelatedTo":
+      return {
+        description: `Compare types ${event.args.sourceId} and ${event.args.targetId}`,
+        timeMs,
+        children,
+        types: [
+          getHotType({
+            id: event.args.sourceId,
+            typeRegistry
+          }),
+          getHotType({
+            id: event.args.targetId,
+            typeRegistry
+          })
+        ]
+      };
+    case "getVariancesWorker":
+      return {
+        description: `Determine variance of type ${event.args.id}`,
+        timeMs,
+        children,
+        types: [getHotType({ id: event.args.id, typeRegistry })]
+      };
+    case "checkExpression":
+    case "checkVariableDeclaration": {
+      const filePath = event.args.path;
+      const path = filePath ? { path: normalize(filePath) } : {};
+      const frame = {
+        description: event.name,
+        timeMs,
+        ...path,
+        children: []
+      };
+      return frame;
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/node-module-paths.ts
+import {
+  packageNameRegex
+} from "@typeslayer/validate";
+function getNodeModulePaths(traceJson) {
+  const nodeModulePaths2 = {};
+  traceJson.forEach((event) => {
+    if (event.name !== "findSourceFile") {
+      return;
+    }
+    const path = event.args.fileName;
+    if (path) {
+      while (true) {
+        const match = packageNameRegex.exec(path);
+        if (!match) {
+          break;
+        }
+        const packageName2 = match[1];
+        const packagePath2 = match.input.substring(
+          0,
+          match.index + match[0].length
+        );
+        if (packageName2 in nodeModulePaths2) {
+          const paths = nodeModulePaths2[packageName2];
+          if (paths && paths.indexOf(packagePath2) < 0) {
+            paths.push(packagePath2);
+          }
+        } else {
+          nodeModulePaths2[packageName2] = [packagePath2];
+        }
+      }
+    }
+  });
+  return nodeModulePaths2;
+}
+
+// src/spans.ts
+import {
+  eventPhase
+} from "@typeslayer/validate";
+function createSpans(traceFile) {
+  const unclosedStack = [];
+  const spans = [];
+  traceFile.forEach((event) => {
+    switch (event.ph) {
+      case eventPhase.begin:
+        unclosedStack.push(event);
+        return;
+      case eventPhase.end: {
+        const beginEvent = unclosedStack.pop();
+        if (!beginEvent) {
+          throw new Error("Unmatched end event");
+        }
+        spans.push({
+          event: beginEvent,
+          start: beginEvent.ts,
+          end: event.ts,
+          duration: event.ts - beginEvent.ts,
+          children: []
+        });
+        break;
+      }
+      case eventPhase.complete: {
+        const start = event.ts;
+        const duration = event.dur ?? 0;
+        spans.push({
+          event,
+          start,
+          end: start + duration,
+          duration,
+          children: []
+        });
+        break;
+      }
+      case eventPhase.instantGlobal:
+      case eventPhase.metadata:
+        return;
+      default:
+        event;
+    }
+  });
+  const parseResult2 = {
+    firstSpanStart: Math.min(...spans.map((span) => span.start)),
+    lastSpanEnd: Math.max(...spans.map((span) => span.end)),
+    spans,
+    unclosedStack
+  };
+  return parseResult2;
+}
+function createSpanTree(parseResult2, options) {
+  const { firstSpanStart, lastSpanEnd, spans, unclosedStack } = parseResult2;
+  for (let i = unclosedStack.length - 1; i >= 0; i--) {
+    const event = unclosedStack[i];
+    const start = event.ts;
+    const end = lastSpanEnd;
+    spans.push({
+      event,
+      start,
+      end,
+      duration: end - start,
+      children: []
+    });
+  }
+  spans.sort((a, b) => a.start - b.start);
+  const root = {
+    event: {
+      name: "root",
+      cat: "program"
+    },
+    start: firstSpanStart,
+    end: lastSpanEnd,
+    duration: lastSpanEnd - firstSpanStart,
+    children: []
+  };
+  const stack = [root];
+  for (const span of spans) {
+    let i = stack.length - 1;
+    for (; i > 0; i--) {
+      const curr = stack[i];
+      if (curr.end > span.start) {
+        stack.length = i + 1;
+        break;
+      }
+    }
+    const thresholdDuration = options.forceMillis * 1e3;
+    const isAboveThresholdDuration = span.duration >= thresholdDuration;
+    const parent = stack[i];
+    const parentDuration = parent.end - parent.start;
+    const isSignificantPortionOfParent = span.duration >= parentDuration * options.minSpanParentPercentage;
+    if (isAboveThresholdDuration || isSignificantPortionOfParent) {
+      parent.children.push(span);
+      stack.push(span);
+    }
+  }
+  return root;
+}
+
+// src/utils.ts
+import { existsSync as existsSync2 } from "fs";
+import { stat } from "fs/promises";
+import {
+  event_checktypes__checkCrossProductUnion_DepthLimit as event_checktypes__checkCrossProductUnion_DepthLimit2,
+  event_checktypes__checkTypeRelatedTo_DepthLimit as event_checktypes__checkTypeRelatedTo_DepthLimit2,
+  event_checktypes__getTypeAtFlowNode_DepthLimit as event_checktypes__getTypeAtFlowNode_DepthLimit2,
+  event_checktypes__instantiateType_DepthLimit as event_checktypes__instantiateType_DepthLimit2,
+  event_checktypes__recursiveTypeRelatedTo_DepthLimit as event_checktypes__recursiveTypeRelatedTo_DepthLimit2,
+  event_checktypes__removeSubtypes_DepthLimit as event_checktypes__removeSubtypes_DepthLimit2,
+  event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit as event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit2,
+  event_checktypes__typeRelatedToDiscriminatedType_DepthLimit as event_checktypes__typeRelatedToDiscriminatedType_DepthLimit2,
+  resolvedType,
+  traceEvent
+} from "@typeslayer/validate";
+import { z } from "zod/v4";
+var absolutePath = z.string().refine(
+  (path) => {
+    return path.startsWith("/") || path.startsWith("C:\\") || path.startsWith("D:\\");
+  },
+  {
+    message: "Path must be absolute"
+  }
+);
+var project = z.object({
+  configFilePath: absolutePath.optional(),
+  tracePath: absolutePath,
+  typesPath: absolutePath
+});
+var projectResult = z.object({
+  project,
+  stdout: z.string(),
+  stderr: z.string(),
+  exitCode: z.number().optional(),
+  signal: z.enum(["SIGINT", "SIGTERM"]).optional()
+});
+var hotType = z.object({
+  resolvedType,
+  get children() {
+    return z.array(hotType);
+  }
+});
+var hotSpot = z.object({
+  description: z.string(),
+  timeMs: z.number(),
+  get children() {
+    return z.array(hotSpot);
+  },
+  path: absolutePath.optional(),
+  types: z.array(hotType).optional(),
+  startLine: z.number().optional(),
+  startChar: z.number().optional(),
+  startOffset: z.number().optional(),
+  endLine: z.number().optional(),
+  endChar: z.number().optional(),
+  endOffset: z.number().optional()
+});
+var duplicatedPackageInstance = z.object({
+  path: absolutePath,
+  version: z.string()
+});
+var duplicatedPackage = z.object({
+  name: z.string(),
+  instances: z.array(duplicatedPackageInstance)
+});
+var rootSpan = z.object({
+  name: z.literal("root"),
+  cat: z.literal("program")
+});
+var eventSpan = z.object({
+  event: z.union([traceEvent, rootSpan]),
+  start: z.number(),
+  end: z.number(),
+  duration: z.number(),
+  get children() {
+    return z.array(eventSpan);
+  }
+});
+var microseconds = z.number();
+var packageName = z.string();
+var packagePath = z.string();
+var nodeModulePaths = z.record(packageName, z.array(packagePath));
+var parseResult = z.object({
+  firstSpanStart: z.number(),
+  lastSpanEnd: z.number(),
+  spans: z.array(eventSpan),
+  unclosedStack: z.array(traceEvent)
+});
+var analyzeTraceOptions = z.object({
+  /** Events of at least this duration (in milliseconds) will reported unconditionally */
+  forceMillis: z.number(),
+  /** Events of less than this duration (in milliseconds) will suppressed unconditionally */
+  skipMillis: z.number(),
+  /** Expand types when printing */
+  expandTypes: z.boolean(),
+  /** force showing spans that are some percentage of their parent, independent of parent time */
+  minSpanParentPercentage: z.number(),
+  /** the minimum number of emitted imports from a declaration file or bundle */
+  importExpressionThreshold: z.number()
+});
+var isFile = async (path) => {
+  return stat(path).then((stats) => stats.isFile()).catch((_) => false);
+};
+var throwIfNotDirectory = async (path) => {
+  if (!existsSync2(path) || !(await stat(path))?.isDirectory()) {
+    throw new Error(`${path} is not a directory`);
+  }
+  return path;
+};
+var analyzeTraceResult = z.object({
+  /** Events that were not closed */
+  unterminatedEvents: z.array(traceEvent),
+  /** Hot spots in the trace */
+  hotSpots: z.array(hotSpot),
+  /** Packages that are duplicated in the trace */
+  duplicatePackages: z.array(duplicatedPackage),
+  /** Paths to all node modules used in the trace */
+  nodeModulePaths,
+  /** Depth limit events grouped by their event name */
+  depthLimits: z.object({
+    checkCrossProductUnion_DepthLimit: z.array(
+      event_checktypes__checkCrossProductUnion_DepthLimit2
+    ),
+    checkTypeRelatedTo_DepthLimit: z.array(
+      event_checktypes__checkTypeRelatedTo_DepthLimit2
+    ),
+    getTypeAtFlowNode_DepthLimit: z.array(
+      event_checktypes__getTypeAtFlowNode_DepthLimit2
+    ),
+    instantiateType_DepthLimit: z.array(
+      event_checktypes__instantiateType_DepthLimit2
+    ),
+    recursiveTypeRelatedTo_DepthLimit: z.array(
+      event_checktypes__recursiveTypeRelatedTo_DepthLimit2
+    ),
+    removeSubtypes_DepthLimit: z.array(
+      event_checktypes__removeSubtypes_DepthLimit2
+    ),
+    traceUnionsOrIntersectionsTooLarge_DepthLimit: z.array(
+      event_checktypes__traceUnionsOrIntersectionsTooLarge_DepthLimit2
+    ),
+    typeRelatedToDiscriminatedType_DepthLimit: z.array(
+      event_checktypes__typeRelatedToDiscriminatedType_DepthLimit2
+    )
+  })
+});
+
+// src/analyze-trace.ts
+function validateOptions(options) {
+  if (options.forceMillis < options.skipMillis) {
+    throw new Error("forceMillis cannot be less than skipMillis");
+  }
+}
+var validateTraceDir = async (traceDir) => {
+  await throwIfNotDirectory(traceDir);
+  const typesFilePath = join2(traceDir, TYPES_JSON_FILENAME);
+  if (!existsSync3(typesFilePath)) {
+    throw new Error(
+      `types.json must exist in ${traceDir}. first run --generateTrace`
+    );
+  }
+  const typesFileJson = JSON.parse(await readFile2(typesFilePath, "utf8"));
+  const typesFile = typesJsonSchema.parse(typesFileJson);
+  const traceFilePath = join2(traceDir, TRACE_JSON_FILENAME);
+  if (!existsSync3(traceFilePath)) {
+    throw new Error(
+      `trace.json must exist in ${traceDir}. first run --generateTrace`
+    );
+  }
+  const traceFileJson = JSON.parse(await readFile2(traceFilePath, "utf8"));
+  const traceFile = traceJsonSchema.parse(traceFileJson);
+  return {
+    traceFile,
+    typesFile
+  };
+};
+var defaultOptions = {
+  forceMillis: 500,
+  skipMillis: 100,
+  expandTypes: true,
+  minSpanParentPercentage: 0.6,
+  importExpressionThreshold: 10
+};
+var analyzeTrace = async ({
+  traceDir,
+  options = defaultOptions
+}) => {
+  validateOptions(options);
+  const { traceFile, typesFile } = await validateTraceDir(traceDir);
+  const nodeModulePaths2 = getNodeModulePaths(traceFile);
+  const spans = createSpans(traceFile);
+  const hotPathsTree = createSpanTree(spans, options);
+  const result = {
+    nodeModulePaths: nodeModulePaths2,
+    unterminatedEvents: spans.unclosedStack.reverse(),
+    hotSpots: await getHotspots(hotPathsTree, typesFile, options),
+    duplicatePackages: await getDuplicateNodeModules(nodeModulePaths2),
+    depthLimits: createDepthLimits(traceFile)
+  };
+  await writeFile(
+    join2(traceDir, ANALYZE_TRACE_FILENAME),
+    JSON.stringify(result, null, 2)
+  );
+  return result;
+};
+export {
+  ANALYZE_TRACE_FILENAME,
+  absolutePath,
+  analyzeTrace,
+  analyzeTraceOptions,
+  analyzeTraceResult,
+  createDepthLimits,
+  defaultOptions,
+  duplicatedPackage,
+  duplicatedPackageInstance,
+  eventSpan,
+  hotSpot,
+  hotType,
+  isFile,
+  microseconds,
+  nodeModulePaths,
+  packageName,
+  packagePath,
+  parseResult,
+  project,
+  projectResult,
+  rootSpan,
+  throwIfNotDirectory,
+  validateOptions
+};
+//# sourceMappingURL=index.js.map