@tsvm/ts-semantics 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { ProjectSemanticGraph, TypeFact, ModuleInfo, DependencyEdge, SymbolAlias } from '@tsvm/shared';
+import ts from 'typescript';
+
+declare function analyzeProject(tsconfigPath: string, entryPoints?: readonly string[]): ProjectSemanticGraph;
+
+declare function extractTypeFacts(sourceFile: ts.SourceFile, checker: ts.TypeChecker): TypeFact[];
+
+declare function buildModuleGraph(program: ts.Program, checker: ts.TypeChecker): {
+    modules: Map<string, ModuleInfo>;
+    dependencyEdges: DependencyEdge[];
+    entries: string[];
+};
+
+declare function buildSymbolTable(modules: Map<string, ModuleInfo>): {
+    symbolTable: TypeFact[];
+    aliases: Map<number, SymbolAlias>;
+};
+
+export { analyzeProject, buildModuleGraph, buildSymbolTable, extractTypeFacts };

package/dist/index.js

@@ -0,0 +1,344 @@
+// src/project.ts
+import ts3 from "typescript";
+import { DiagnosticSeverity } from "@tsvm/shared";
+
+// src/module-graph.ts
+import ts2 from "typescript";
+import { TypeFactKind as TypeFactKind2 } from "@tsvm/shared";
+
+// src/type-facts.ts
+import ts from "typescript";
+import { TypeFactKind } from "@tsvm/shared";
+function getSourceLocation(node) {
+  const sourceFile = node.getSourceFile();
+  const start = node.getStart();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+  return {
+    filePath: sourceFile.fileName,
+    line,
+    column: character,
+    offset: start,
+    length: node.getEnd() - start
+  };
+}
+function extractTypeFacts(sourceFile, checker) {
+  const facts = [];
+  function visit(node) {
+    if (ts.isVariableDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node) || ts.isParameter(node) || ts.isPropertyDeclaration(node) || ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isConstructorDeclaration(node)) {
+      if (node.name && ts.isIdentifier(node.name)) {
+        const symbol = checker.getSymbolAtLocation(node.name);
+        if (symbol) {
+          const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+          const typeText = checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
+          let kind = TypeFactKind.Variable;
+          if (ts.isFunctionDeclaration(node)) kind = TypeFactKind.Function;
+          else if (ts.isClassDeclaration(node)) kind = TypeFactKind.Class;
+          else if (ts.isInterfaceDeclaration(node)) kind = TypeFactKind.Interface;
+          else if (ts.isTypeAliasDeclaration(node)) kind = TypeFactKind.TypeAlias;
+          else if (ts.isEnumDeclaration(node)) kind = TypeFactKind.Enum;
+          else if (ts.isModuleDeclaration(node)) kind = TypeFactKind.Namespace;
+          else if (ts.isParameter(node)) kind = TypeFactKind.Parameter;
+          else if (ts.isPropertyDeclaration(node)) kind = TypeFactKind.Property;
+          else if (ts.isMethodDeclaration(node)) kind = TypeFactKind.Method;
+          else if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) kind = TypeFactKind.Accessor;
+          else if (ts.isConstructorDeclaration(node)) kind = TypeFactKind.Constructor;
+          let isExported = false;
+          let isAmbient = false;
+          if (ts.canHaveModifiers(node)) {
+            const modifiers = ts.getModifiers(node);
+            isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+            isAmbient = modifiers?.some((m) => m.kind === ts.SyntaxKind.DeclareKeyword) ?? false;
+          }
+          let isGeneric = false;
+          const typeParameters = [];
+          const constraints = [];
+          if ("typeParameters" in node) {
+            const nodeWithTP = node;
+            const tps = nodeWithTP.typeParameters;
+            if (tps) {
+              isGeneric = true;
+              tps.forEach((tp) => {
+                typeParameters.push(tp.name.text);
+                if (tp.constraint) {
+                  constraints.push(tp.constraint.getText());
+                }
+              });
+            }
+          }
+          const decorators = [];
+          if (ts.canHaveDecorators(node)) {
+            const decs = ts.getDecorators(node);
+            if (decs) {
+              decs.forEach((d) => decorators.push(d.expression.getText()));
+            }
+          }
+          facts.push({
+            symbolName: symbol.name,
+            symbolId: symbol.id ?? -1,
+            kind,
+            typeText,
+            flags: type.flags,
+            isGeneric,
+            typeParameters,
+            constraints,
+            sourceLocation: getSourceLocation(node),
+            isExported,
+            isAmbient,
+            decorators
+          });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return facts;
+}
+
+// src/module-graph.ts
+function buildModuleGraph(program, checker) {
+  const modules = /* @__PURE__ */ new Map();
+  const dependencyEdges = [];
+  const entries = [];
+  const sourceFiles = program.getSourceFiles().filter((sf) => !sf.isDeclarationFile && !sf.fileName.includes("node_modules"));
+  for (const sf of sourceFiles) {
+    const filePath = sf.fileName;
+    const typeFacts = extractTypeFacts(sf, checker);
+    const exports = [];
+    const imports = [];
+    let hasJSX = false;
+    let hasDecorators = false;
+    ts2.forEachChild(sf, function visit(node) {
+      if (ts2.isJsxElement(node) || ts2.isJsxSelfClosingElement(node) || ts2.isJsxFragment(node)) {
+        hasJSX = true;
+      }
+      if (ts2.canHaveDecorators(node) && ts2.getDecorators(node)?.length) {
+        hasDecorators = true;
+      }
+      if (ts2.isImportDeclaration(node)) {
+        const moduleSpecifier = node.moduleSpecifier.text;
+        const isTypeOnly = node.importClause?.isTypeOnly ?? false;
+        if (node.importClause) {
+          if (node.importClause.name) {
+            imports.push({
+              localName: node.importClause.name.text,
+              importedName: "default",
+              moduleSpecifier,
+              kind: "default",
+              isTypeOnly
+            });
+          }
+          if (node.importClause.namedBindings) {
+            if (ts2.isNamedImports(node.importClause.namedBindings)) {
+              node.importClause.namedBindings.elements.forEach((el) => {
+                imports.push({
+                  localName: el.name.text,
+                  importedName: el.propertyName ? el.propertyName.text : el.name.text,
+                  moduleSpecifier,
+                  kind: "named",
+                  isTypeOnly: isTypeOnly || el.isTypeOnly
+                });
+              });
+            } else if (ts2.isNamespaceImport(node.importClause.namedBindings)) {
+              imports.push({
+                localName: node.importClause.namedBindings.name.text,
+                importedName: "*",
+                moduleSpecifier,
+                kind: "namespace",
+                isTypeOnly
+              });
+            }
+          }
+        } else {
+          imports.push({
+            localName: "",
+            importedName: "",
+            moduleSpecifier,
+            kind: "side_effect",
+            isTypeOnly: false
+          });
+        }
+      }
+      if (ts2.isCallExpression(node) && node.expression.kind === ts2.SyntaxKind.ImportKeyword) {
+        if (node.arguments.length > 0 && ts2.isStringLiteral(node.arguments[0])) {
+          const moduleSpecifier = node.arguments[0].text;
+          dependencyEdges.push({
+            fromModule: filePath,
+            toModule: moduleSpecifier,
+            // Will resolve properly later if needed
+            symbols: [],
+            isTypeOnly: false,
+            isDynamic: true
+          });
+        }
+      }
+      if (ts2.isExportDeclaration(node)) {
+        const isTypeOnly = node.isTypeOnly;
+        if (node.exportClause && ts2.isNamedExports(node.exportClause)) {
+          node.exportClause.elements.forEach((el) => {
+            exports.push({
+              localName: el.propertyName ? el.propertyName.text : el.name.text,
+              exportedName: el.name.text,
+              kind: TypeFactKind2.Variable,
+              // Approximate, could be refined
+              isTypeOnly: isTypeOnly || el.isTypeOnly,
+              isDefault: el.name.text === "default",
+              isReExport: !!node.moduleSpecifier,
+              sourceModule: node.moduleSpecifier ? node.moduleSpecifier.text : void 0
+            });
+          });
+        }
+      } else if (ts2.canHaveModifiers(node) && ts2.getModifiers(node)?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword)) {
+        const isDefault = ts2.getModifiers(node).some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword);
+        let name = "default";
+        if (!isDefault && node.name && ts2.isIdentifier(node.name)) {
+          name = node.name.text;
+        } else if (!isDefault && ts2.isVariableStatement(node)) {
+          node.declarationList.declarations.forEach((d) => {
+            if (ts2.isIdentifier(d.name)) {
+              exports.push({
+                localName: d.name.text,
+                exportedName: d.name.text,
+                kind: TypeFactKind2.Variable,
+                isTypeOnly: false,
+                isDefault: false,
+                isReExport: false
+              });
+            }
+          });
+          return;
+        }
+        if (node.name || isDefault) {
+          exports.push({
+            localName: isDefault && node.name ? node.name.text : name,
+            exportedName: name,
+            kind: TypeFactKind2.Function,
+            // Approximate
+            isTypeOnly: ts2.isInterfaceDeclaration(node) || ts2.isTypeAliasDeclaration(node),
+            isDefault,
+            isReExport: false
+          });
+        }
+      }
+      ts2.forEachChild(node, visit);
+    });
+    const isEntryPoint = exports.length > 0;
+    if (isEntryPoint) entries.push(filePath);
+    modules.set(filePath, {
+      filePath,
+      relativePath: program.getCurrentDirectory() ? filePath.replace(program.getCurrentDirectory(), "") : filePath,
+      exports,
+      imports,
+      typeFacts,
+      isEntryPoint,
+      isDeclarationFile: sf.isDeclarationFile,
+      hasJSX,
+      hasDecorators,
+      byteSize: sf.text.length
+    });
+  }
+  for (const [filePath, mod] of modules.entries()) {
+    const targetMap = /* @__PURE__ */ new Map();
+    for (const imp of mod.imports) {
+      const target = imp.moduleSpecifier;
+      if (!targetMap.has(target)) {
+        targetMap.set(target, { symbols: [], isTypeOnly: true });
+      }
+      const entry = targetMap.get(target);
+      entry.symbols.push(imp.importedName);
+      if (!imp.isTypeOnly) entry.isTypeOnly = false;
+    }
+    for (const [target, info] of targetMap.entries()) {
+      dependencyEdges.push({
+        fromModule: filePath,
+        toModule: target,
+        symbols: info.symbols,
+        isTypeOnly: info.isTypeOnly,
+        isDynamic: false
+      });
+    }
+  }
+  return { modules, dependencyEdges, entries };
+}
+
+// src/symbol-table.ts
+import { ScopeKind } from "@tsvm/shared";
+function buildSymbolTable(modules) {
+  const symbolTable = [];
+  const aliases = /* @__PURE__ */ new Map();
+  let nextSymbolId = 1;
+  for (const [filePath, mod] of modules.entries()) {
+    for (const fact of mod.typeFacts) {
+      const normalizedId = nextSymbolId++;
+      const normalizedFact = {
+        ...fact,
+        symbolId: normalizedId
+      };
+      symbolTable.push(normalizedFact);
+      aliases.set(normalizedId, {
+        originalName: fact.symbolName,
+        obfuscatedName: fact.symbolName,
+        // Will be changed by SymbolIndirectionPass
+        scope: fact.isExported ? ScopeKind.Module : ScopeKind.Block,
+        // Simplified
+        symbolId: normalizedId,
+        isExported: fact.isExported
+      });
+    }
+  }
+  return { symbolTable, aliases };
+}
+
+// src/project.ts
+import path from "path";
+function analyzeProject(tsconfigPath, entryPoints) {
+  const diagnostics = [];
+  const configFile = ts3.readConfigFile(tsconfigPath, ts3.sys.readFile);
+  if (configFile.error) {
+    throw new Error(`Failed to read tsconfig: ${configFile.error.messageText}`);
+  }
+  const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path.dirname(tsconfigPath));
+  if (parsedConfig.errors.length > 0) {
+    const errorMsg = parsedConfig.errors.map((e) => e.messageText).join(", ");
+    throw new Error(`Invalid tsconfig: ${errorMsg}`);
+  }
+  const rootNames = entryPoints && entryPoints.length > 0 ? entryPoints : parsedConfig.fileNames;
+  const program = ts3.createProgram({
+    rootNames,
+    options: parsedConfig.options
+  });
+  const checker = program.getTypeChecker();
+  const { modules, dependencyEdges, entries } = buildModuleGraph(program, checker);
+  const { symbolTable, aliases } = buildSymbolTable(modules);
+  const tsDiagnostics = ts3.getPreEmitDiagnostics(program);
+  for (const diag of tsDiagnostics) {
+    diagnostics.push({
+      severity: diag.category === 1 ? DiagnosticSeverity.Error : diag.category === 0 ? DiagnosticSeverity.Warning : DiagnosticSeverity.Info,
+      code: `TS${diag.code}`,
+      message: ts3.flattenDiagnosticMessageText(diag.messageText, "\n"),
+      location: diag.file ? {
+        filePath: diag.file.fileName,
+        line: diag.file.getLineAndCharacterOfPosition(diag.start).line,
+        column: diag.file.getLineAndCharacterOfPosition(diag.start).character,
+        offset: diag.start,
+        length: diag.length
+      } : void 0
+    });
+  }
+  return {
+    rootDir: program.getCurrentDirectory(),
+    modules,
+    dependencyEdges,
+    entryPoints: entries,
+    symbolTable,
+    aliases,
+    compilerOptions: parsedConfig.options,
+    diagnostics
+  };
+}
+export {
+  analyzeProject,
+  buildModuleGraph,
+  buildSymbolTable,
+  extractTypeFacts
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tsvm/ts-semantics",
+  "version": "0.1.0",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup ./src/index.ts --format esm --dts --clean",
+    "test": "pnpm --dir ../.. exec vitest run packages/ts-semantics/tests/**/*.test.ts --config vitest.config.mjs",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@tsvm/shared": "workspace:*",
+    "typescript": "^5.8.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0"
+  }
+}